Merge pull request #48 from kris7t/validator

Improve content assist and validator

7 files changed, 145 insertions, 31 deletions

diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
index 61037be3..c85bd8b7 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
@@ -52,9 +52,10 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
 
         private final Symbol<InferredContainment> containsStorage = Symbol.of("CONTAINS", 2, InferredContainment.class,
                         InferredContainment.UNKNOWN);
+        private final AnySymbolView mustAnyContainmentLinkView = new MustAnyContainmentLinkView(containsStorage);
         private final AnySymbolView forbiddenContainsView = new ForbiddenContainsView(containsStorage);
         private final RelationalQuery containsMayNewTargetHelper;
-        private final RelationalQuery containsMayExistingHelper;
+        private final RelationalQuery containsWithoutLink;
         private final RelationalQuery weakComponents;
         private final RelationalQuery strongComponents;
         private final Map<PartialRelation, ContainmentInfo> containmentInfoMap;
@@ -67,18 +68,15 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                 containsMayNewTargetHelper = Query.of(name + "#mayNewTargetHelper", (builder, child) -> builder
                                 .clause(Integer.class, existingContainers -> List.of(
                                                 may(CONTAINED_SYMBOL.call(child)),
-                                                new CountLowerBoundLiteral(existingContainers, CONTAINS_SYMBOL, List.of(Variable.of(), child)),
+                                                new CountLowerBoundLiteral(existingContainers, CONTAINS_SYMBOL,
+                                                                List.of(Variable.of(), child)),
                                                 check(less(existingContainers, constant(1)))
                                 )));
 
-                containsMayExistingHelper = Query.of(name + "#mayExistingHelper", (builder, parent, child) -> builder
-                                .clause(Integer.class, existingContainers -> List.of(
-                                                must(CONTAINS_SYMBOL.call(parent, child)),
-                                                not(forbiddenContainsView.call(parent, child))
-                                                // Violation of monotonicity:
-                                                // Containment edges violating upper multiplicity will not be marked as {@code ERROR}, but the
-                                                // {@code invalidNumberOfContainers} error pattern will already mark the node as invalid.
-                                )));
+                containsWithoutLink = Query.of(name + "#withoutLink", (builder, parent, child) -> builder.clause(
+                                must(CONTAINS_SYMBOL.call(parent, child)),
+                                not(mustAnyContainmentLinkView.call(parent, child))
+                ));
 
                 var mustExistBothContains = Query.of(name + "#mustExistBoth", (builder, parent, child) -> builder.clause(
                                 must(CONTAINS_SYMBOL.call(parent, child)),
@@ -139,13 +137,21 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                 var mayNewHelper = Query.of(name + "#mayNewHelper", (builder, parent, child) -> builder.clause(
                                 mayNewSourceHelper.call(parent),
                                 mayNewTargetHelper.call(child),
-                                not(must(CONTAINS_SYMBOL.call(parent, child))),
+                                not(mustAnyContainmentLinkView.call(parent, child)),
                                 not(forbiddenLinkView.call(parent, child))
                 ));
 
+                var existingContainsLink = Query.of(name + "#existingContaints", (builder, parent, child) -> builder
+                                .clause(
+                                                must(linkType.call(parent, child))
+                                )
+                                .clause(
+                                                containsWithoutLink.call(parent, child)
+                                ));
+
                 var mayExistingHelper = Query.of(name + "#mayExistingHelper", (builder, parent, child) -> builder.clause(
-                                must(linkType.call(parent, child)),
-                                containsMayExistingHelper.call(parent, child),
+                                existingContainsLink.call(parent, child),
+                                not(forbiddenContainsView.call(parent, child)),
                                 may(sourceType.call(parent)),
                                 may(targetType.call(child)),
                                 not(forbiddenLinkView.call(parent, child))
@@ -224,7 +230,9 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                                 }))
                                 .must(Query.of(mustName, (builder, parent, child) -> builder.clause(
                                                 new MustContainsView(containsStorage).call(parent, child)
-                                ))));
+                                )))
+                                .refiner(ContainsRefiner.of(containsStorage))
+                                .initializer(new RefinementBasedInitializer<>(CONTAINS_SYMBOL)));
         }
 
         private void translateInvalidContainer(ModelStoreBuilder storeBuilder) {
@@ -245,7 +253,7 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                                 )
                                 .clause(container -> List.of(
                                                 MultiObjectTranslator.MULTI_VIEW.call(multi),
-                                                must(CONTAINS_SYMBOL.call(container, multi)),
+                                                mustAnyContainmentLinkView.call(container, multi),
                                                 not(MultiObjectTranslator.MULTI_VIEW.call(container))
                                 ))
                                 .action(
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
index 497ed98f..e44fcffd 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
@@ -24,8 +24,8 @@ class ContainmentLinkRefiner extends AbstractPartialInterpretationRefiner<TruthV
         private final PartialInterpretationRefiner<TruthValue, Boolean> sourceRefiner;
         private final PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
 
-        public ContainmentLinkRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
-                                                                  Factory factory) {
+        private ContainmentLinkRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                                   Factory factory) {
                 super(adapter, partialSymbol);
                 this.factory = factory;
                 interpretation = adapter.getModel().getInterpretation(factory.symbol);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java
new file mode 100644
index 00000000..a7196a1c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.AbstractPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+class ContainsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, Boolean> {
+        private static final Map<TruthValue, InferredContainment> EMPTY_VALUES;
+
+        static {
+                var values = TruthValue.values();
+                EMPTY_VALUES = new LinkedHashMap<>(values.length);
+                for (var value : values) {
+                        EMPTY_VALUES.put(value, new InferredContainment(value, Set.of(), Set.of()));
+                }
+        }
+
+        private final Interpretation<InferredContainment> interpretation;
+        private final PartialInterpretationRefiner<TruthValue, Boolean> containedRefiner;
+
+        private ContainsRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                        Symbol<InferredContainment> containsStorage) {
+                super(adapter, partialSymbol);
+                interpretation = adapter.getModel().getInterpretation(containsStorage);
+                containedRefiner = adapter.getRefiner(ContainmentHierarchyTranslator.CONTAINED_SYMBOL);
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                var oldValue = interpretation.get(key);
+                var newValue = mergeLink(oldValue, value);
+                if (oldValue != newValue) {
+                        interpretation.put(key, newValue);
+                }
+                if (value.must()) {
+                        return containedRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
+                }
+                return true;
+        }
+
+        public InferredContainment mergeLink(InferredContainment oldValue, TruthValue toMerge) {
+                var newContains = oldValue.contains().merge(toMerge);
+                if (newContains.equals(oldValue.contains())) {
+                        return oldValue;
+                }
+                var mustLinks = oldValue.mustLinks();
+                var forbiddenLinks = oldValue.forbiddenLinks();
+                if (mustLinks.isEmpty() && forbiddenLinks.isEmpty()) {
+                        return EMPTY_VALUES.get(newContains);
+                }
+                return new InferredContainment(newContains, mustLinks, forbiddenLinks);
+        }
+
+        public static PartialInterpretationRefiner.Factory<TruthValue, Boolean> of(Symbol<InferredContainment> symbol) {
+                return (adapter, partialSymbol) -> new ContainsRefiner(adapter, partialSymbol, symbol);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
index 8df23d9a..8a757ed2 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
@@ -24,7 +24,7 @@ final class InferredContainment {
                 this.contains = adjustContains(contains, mustLinks, forbiddenLinks);
                 this.mustLinks = mustLinks;
                 this.forbiddenLinks = forbiddenLinks;
-                hashCode = Objects.hash(contains, mustLinks, forbiddenLinks);
+                hashCode = Objects.hash(this.contains, mustLinks, forbiddenLinks);
         }
 
         private static TruthValue adjustContains(TruthValue contains, Set<PartialRelation> mustLinks,
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustAnyContainmentLinkView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustAnyContainmentLinkView.java
new file mode 100644
index 00000000..1cc537c6
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustAnyContainmentLinkView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.query.view.TuplePreservingView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class MustAnyContainmentLinkView extends TuplePreservingView<InferredContainment> {
+        public MustAnyContainmentLinkView(Symbol<InferredContainment> symbol) {
+                super(symbol, "contains#mustAnyLink");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredContainment value) {
+                return !value.mustLinks().isEmpty();
+        }
+}
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();