feat(language): opposite reference validation

15 files changed, 555 insertions, 41 deletions

diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
index 899e3cb3..b4abce81 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
@@ -77,7 +77,7 @@ class ModelGenerationTest {
                                 % Scope
                                 scope Post = 5, Person = 5.
                                 """);
-                assertThat(parsedProblem.errors(), empty());
+                assertThat(parsedProblem.getResourceErrors(), empty());
                 var problem = parsedProblem.problem();
 
                 var storeBuilder = ModelStore.builder()
@@ -211,7 +211,7 @@ class ModelGenerationTest {
 
                                 scope node = 200..210, Region = 10..*, Choice = 1..*, Statechart = 1.
                                 """);
-                assertThat(parsedProblem.errors(), empty());
+                assertThat(parsedProblem.getResourceErrors(), empty());
                 var problem = parsedProblem.problem();
 
                 var storeBuilder = ModelStore.builder()
@@ -278,7 +278,7 @@ class ModelGenerationTest {
 
                                 scope Filesystem += 0, Entry = 100.
                                 """);
-                assertThat(parsedProblem.errors(), empty());
+                assertThat(parsedProblem.getResourceErrors(), empty());
                 var problem = parsedProblem.problem();
 
                 var storeBuilder = ModelStore.builder()
diff --git a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
index 0a91178b..0fb96954 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -40,10 +40,13 @@ enum ReferenceKind:
 ReferenceDeclaration:
         (referenceType=[Relation|NonContainmentQualifiedName] |
         kind=ReferenceKind referenceType=[Relation|QualifiedName])
-        ("[" multiplicity=Multiplicity "]")?
+        (multiplicity=ReferenceMultiplicity)?
         name=Identifier
         ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?;
 
+ReferenceMultiplicity returns Multiplicity:
+        "[" Multiplicity "]";
+
 //enum PrimitiveType:
 //      INT="int" | REAL="real" | STRING="string";
 //
diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
index 100f3781..0a5cb3c2 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
@@ -20,6 +20,7 @@ import org.eclipse.xtext.scoping.IGlobalScopeProvider;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
 import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
+import org.eclipse.xtext.validation.IDiagnosticConverter;
 import org.eclipse.xtext.validation.IResourceValidator;
 import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
 import tools.refinery.language.conversion.ProblemValueConverterService;
@@ -33,6 +34,7 @@ import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
 import tools.refinery.language.scoping.ProblemGlobalScopeProvider;
 import tools.refinery.language.scoping.ProblemLocalScopeProvider;
 import tools.refinery.language.serializer.PreferShortAssertionsProblemSemanticSequencer;
+import tools.refinery.language.validation.ProblemDiagnosticConverter;
 
 /**
  * Use this class to register components to be used at runtime / without the
@@ -101,4 +103,8 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         public Class<? extends ISemanticSequencer> bindISemanticSequencer() {
                 return PreferShortAssertionsProblemSemanticSequencer.class;
         }
+
+        public Class<? extends IDiagnosticConverter> bindIDiagnosticConverter() {
+                return ProblemDiagnosticConverter.class;
+        }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
index b3c93b07..7b6407e1 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
@@ -7,11 +7,12 @@ package tools.refinery.language.utils;
 
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
 import tools.refinery.language.model.problem.*;
 
 public final class ProblemUtil {
         public static final String BUILTIN_LIBRARY_NAME = "builtin";
-        public static final URI BUILTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME);
+        public static final URI BUILTIN_LIBRARY_URI = getLibraryUri();
 
         private ProblemUtil() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
@@ -96,8 +97,31 @@ public final class ProblemUtil {
                 throw new IllegalArgumentException("Unknown Relation: " + relation);
         }
 
-        private static URI getLibraryUri(String libraryName) {
-                return URI.createURI(ProblemUtil.class.getClassLoader()
-                                .getResource("tools/refinery/language/%s.problem".formatted(libraryName)).toString());
+        public static boolean isContainerReference(ReferenceDeclaration referenceDeclaration) {
+                var kind = referenceDeclaration.getKind();
+                if (kind == null) {
+                        return false;
+                }
+                return switch (kind) {
+                        case CONTAINMENT -> false;
+                        case CONTAINER -> true;
+                        case REFERENCE -> {
+                                var opposite = referenceDeclaration.getOpposite();
+                                if (opposite == null) {
+                                        yield false;
+                                }
+                                opposite = (ReferenceDeclaration) EcoreUtil.resolve(opposite, referenceDeclaration);
+                                yield opposite.getKind() == ReferenceKind.CONTAINMENT;
+                        }
+                };
+        }
+
+        private static URI getLibraryUri() {
+                var libraryResource = ProblemUtil.class.getClassLoader()
+                                .getResource("tools/refinery/language/%s.problem".formatted(BUILTIN_LIBRARY_NAME));
+                if (libraryResource == null) {
+                        throw new AssertionError("Library '%s' was not found".formatted(BUILTIN_LIBRARY_NAME));
+                }
+                return URI.createURI(libraryResource.toString());
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemDiagnosticConverter.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemDiagnosticConverter.java
new file mode 100644
index 00000000..0b7cc315
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemDiagnosticConverter.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.xtext.validation.DiagnosticConverterImpl;
+import tools.refinery.language.model.problem.Multiplicity;
+import tools.refinery.language.model.problem.ReferenceDeclaration;
+import tools.refinery.language.services.ProblemGrammarAccess;
+
+public class ProblemDiagnosticConverter extends DiagnosticConverterImpl {
+        @Inject
+        private ProblemGrammarAccess grammarAccess;
+
+        @Override
+        protected IssueLocation getLocationData(EObject obj, EStructuralFeature structuralFeature, int index) {
+                if (structuralFeature == null && obj instanceof Multiplicity &&
+                                obj.eContainer() instanceof ReferenceDeclaration referenceDeclaration) {
+                        // Include the enclosing {@code []} square braces in the error location.
+                        // This lets use have a non-0 length error marker for invalid container references such as
+                        // {@code container Foo[] foo opposite bar}, where unbounded multiplicities are disallowed.
+                        return getLocationData(referenceDeclaration, obj.eContainingFeature());
+                }
+                return super.getLocationData(obj, structuralFeature, index);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
index ef04726b..21b175ee 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
@@ -35,6 +35,14 @@ public class ProblemValidator extends AbstractProblemValidator {
 
         public static final String DUPLICATE_NAME_ISSUE = ISSUE_PREFIX + "DUPLICATE_NAME";
 
+        public static final String INVALID_MULTIPLICITY_ISSUE = ISSUE_PREFIX + "INVALID_MULTIPLICITY";
+
+        public static final String ZERO_MULTIPLICITY_ISSUE = ISSUE_PREFIX + "ZERO_MULTIPLICITY";
+
+        public static final String MISSING_OPPOSITE_ISSUE = ISSUE_PREFIX + "MISSING_OPPOSITE";
+
+        public static final String INVALID_OPPOSITE_ISSUE = ISSUE_PREFIX + "INVALID_OPPOSITE";
+
         @Inject
         private ReferenceCounter referenceCounter;
 
@@ -111,4 +119,104 @@ public class ProblemValidator extends AbstractProblemValidator {
                         }
                 }
         }
+
+        @Check
+        public void checkRangeMultiplicity(RangeMultiplicity rangeMultiplicity) {
+                int lower = rangeMultiplicity.getLowerBound();
+                int upper = rangeMultiplicity.getUpperBound();
+                if (upper >= 0 && lower > upper) {
+                        var message = "Multiplicity range [%d..%d] is inconsistent.";
+                        acceptError(message, rangeMultiplicity, null, 0, INVALID_MULTIPLICITY_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkReferenceMultiplicity(ReferenceDeclaration referenceDeclaration) {
+                var multiplicity = referenceDeclaration.getMultiplicity();
+                if (multiplicity == null) {
+                        return;
+                }
+                if (ProblemUtil.isContainerReference(referenceDeclaration) && (
+                                !(multiplicity instanceof RangeMultiplicity rangeMultiplicity) ||
+                                                rangeMultiplicity.getLowerBound() != 0 ||
+                                                rangeMultiplicity.getUpperBound() != 1)) {
+                        var message = "The only allowed multiplicity for container references is [0..1]";
+                        acceptError(message, multiplicity, null, 0, INVALID_MULTIPLICITY_ISSUE);
+                }
+                if ((multiplicity instanceof ExactMultiplicity exactMultiplicity &&
+                                exactMultiplicity.getExactValue() == 0) ||
+                                (multiplicity instanceof RangeMultiplicity rangeMultiplicity &&
+                                                rangeMultiplicity.getLowerBound() == 0 &&
+                                                rangeMultiplicity.getUpperBound() == 0)) {
+                        var message = "The multiplicity constraint does not allow any reference links";
+                        acceptWarning(message, multiplicity, null, 0, ZERO_MULTIPLICITY_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkOpposite(ReferenceDeclaration referenceDeclaration) {
+                var opposite = referenceDeclaration.getOpposite();
+                if (opposite == null || opposite.eIsProxy()) {
+                        return;
+                }
+                var oppositeOfOpposite = opposite.getOpposite();
+                if (oppositeOfOpposite == null) {
+                        acceptError("Reference '%s' does not declare '%s' as an opposite."
+                                                        .formatted(opposite.getName(), referenceDeclaration.getName()),
+                                        referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
+                                        INVALID_OPPOSITE_ISSUE);
+                        var oppositeResource = opposite.eResource();
+                        if (oppositeResource != null && oppositeResource.equals(referenceDeclaration.eResource())) {
+                                acceptError("Missing opposite '%s' for reference '%s'."
+                                                                .formatted(referenceDeclaration.getName(), opposite.getName()),
+                                                opposite, ProblemPackage.Literals.NAMED_ELEMENT__NAME, 0, MISSING_OPPOSITE_ISSUE);
+                        }
+                        return;
+                }
+        if (!referenceDeclaration.equals(oppositeOfOpposite)) {
+            var messageBuilder = new StringBuilder()
+                    .append("Expected reference '")
+                    .append(opposite.getName())
+                    .append("' to have opposite '")
+                    .append(referenceDeclaration.getName())
+                    .append("'");
+            var oppositeOfOppositeName = oppositeOfOpposite.getName();
+            if (oppositeOfOppositeName != null) {
+                messageBuilder.append(", got '")
+                        .append(oppositeOfOppositeName)
+                        .append("' instead");
+            }
+            messageBuilder.append(".");
+            acceptError(messageBuilder.toString(), referenceDeclaration,
+                    ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0, INVALID_OPPOSITE_ISSUE);
+        }
+    }
+
+        @Check
+        void checkContainerOpposite(ReferenceDeclaration referenceDeclaration) {
+                var kind = referenceDeclaration.getKind();
+                var opposite = referenceDeclaration.getOpposite();
+                if (opposite != null && opposite.eIsProxy()) {
+                        // If {@code opposite} is a proxy, we have already emitted a linker error.
+                        return;
+                }
+                if (kind == ReferenceKind.CONTAINMENT) {
+                        if (opposite != null && opposite.getKind() == ReferenceKind.CONTAINMENT) {
+                                acceptError("Opposite '%s' of containment reference '%s' is not a container reference."
+                                                                .formatted(opposite.getName(), referenceDeclaration.getName()),
+                                                referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
+                                                INVALID_OPPOSITE_ISSUE);
+                        }
+                } else if (kind == ReferenceKind.CONTAINER) {
+                        if (opposite == null) {
+                                acceptError("Container reference '%s' requires an opposite.".formatted(referenceDeclaration.getName()),
+                                                referenceDeclaration, ProblemPackage.Literals.NAMED_ELEMENT__NAME, 0, MISSING_OPPOSITE_ISSUE);
+                        } else if (opposite.getKind() != ReferenceKind.CONTAINMENT) {
+                                acceptError("Opposite '%s' of container reference '%s' is not a containment reference."
+                                                                .formatted(opposite.getName(), referenceDeclaration.getName()),
+                                                referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
+                                                INVALID_OPPOSITE_ISSUE);
+                        }
+                }
+        }
 }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
index 96e7cf9c..72d57f54 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
@@ -51,6 +51,6 @@ class ProblemParsingTest {
                                 ?children(bob, ciri).
                                 taxStatus(anne, ADULT).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
         }
 }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/linking/AmbiguousReferenceTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/linking/AmbiguousReferenceTest.java
index b1b24ef3..464c207c 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/linking/AmbiguousReferenceTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/linking/AmbiguousReferenceTest.java
@@ -7,6 +7,7 @@ package tools.refinery.language.tests.linking;
 
 
 import com.google.inject.Inject;
+import org.eclipse.xtext.diagnostics.Diagnostic;
 import org.eclipse.xtext.testing.InjectWith;
 import org.eclipse.xtext.testing.extensions.InjectionExtension;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -57,7 +58,7 @@ class AmbiguousReferenceTest {
                         """})
         void unambiguousReferenceTest(String text) {
                 var problem = parseHelper.parse(text);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
         }
 
         @ParameterizedTest
@@ -88,7 +89,10 @@ class AmbiguousReferenceTest {
                         """})
         void ambiguousReferenceTest(String text) {
                 var problem = parseHelper.parse(text);
-                assertThat(problem.errors(), hasItem(hasProperty("message", stringContainsInOrder(
-                                "Ambiguous reference", "'quux'"))));
+                var errors = problem.getResourceErrors();
+                assertThat(problem.getResourceErrors(), hasItem(allOf(
+                                hasProperty("code", is(Diagnostic.LINKING_DIAGNOSTIC)),
+                                hasProperty("message", containsString("'quux'"))
+                )));
         }
 }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
index ed193e90..a9c5f62a 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
@@ -31,7 +31,7 @@ class TransitiveClosureParserTest {
                 var problem = parseHelper.parse("""
                                         pred foo(a, b) <-> a + (b) > 10.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 var literal = problem.pred("foo").conj(0).lit(0).get();
                 assertThat(literal, instanceOf(ComparisonExpr.class));
                 var left = ((ComparisonExpr) literal).getLeft();
@@ -45,7 +45,7 @@ class TransitiveClosureParserTest {
                 var problem = parseHelper.parse("""
                                         pred foo(a, b) <-> equals+(a, b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 var literal = problem.pred("foo").conj(0).lit(0).get();
                 assertThat(literal, instanceOf(Atom.class));
                 var atom = (Atom) literal;
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java
index 68514bfa..56e65550 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java
@@ -42,7 +42,7 @@ class RuleParsingTest {
                         """ })
         void simpleTest(String text) {
                 var problem = parseHelper.parse(text);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
         }
 
         @Test
@@ -51,7 +51,7 @@ class RuleParsingTest {
                                 pred Person(p).
                                 rule r(p1): must Person(p1) ==> new p2, Person(p2) := unknown.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.rule("r").param(0), equalTo(problem.rule("r").conj(0).lit(0).arg(0).variable()));
                 assertThat(problem.rule("r").consequent(0).action(0).newVar(),
                                 equalTo(problem.rule("r").consequent(0).action(1).assertedAtom().arg(0).variable()));
@@ -63,7 +63,7 @@ class RuleParsingTest {
                                 pred Friend(a, b).
                                 rule r(p1): !may Friend(p1, p2) ==> new p2, Friend(p1, p2) := true.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.rule("r").conj(0).lit(0).negated().arg(1).variable(),
                                 not(equalTo(problem.rule("r").consequent(0).action(1).assertedAtom().arg(1).variable())));
         }
@@ -74,7 +74,7 @@ class RuleParsingTest {
                                 pred Friend(a, b).
                                 rule r(p1, p2): !may Friend(p1, p2) ==> new p2, Friend(p1, p2) := true.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.rule("r").param(1),
                                 not(equalTo(problem.rule("r").consequent(0).action(1).assertedAtom().arg(1).variable())));
         }
@@ -85,6 +85,6 @@ class RuleParsingTest {
                                 pred Person(p).
                                 rule r(p1): must Friend(p1, p2) ==> delete p2.
                                 """);
-                assertThat(problem.errors(), not(empty()));
+                assertThat(problem.getResourceErrors(), not(empty()));
         }
 }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
index 734bfcd1..e76d2993 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
@@ -36,7 +36,7 @@ class NodeScopingTest {
                 var problem = parse("""
                                 pred predicate({PARAM}node a).
                                 """, qualifiedNamePrefix);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.pred("predicate").param(0).getParameterType(),
                                 equalTo(problem.builtin().findClass("node").get()));
         }
@@ -48,7 +48,7 @@ class NodeScopingTest {
                                 predicate(a, a).
                                 ?predicate(a, b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), hasItems("a", "b"));
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("a")));
                 assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.node("a")));
@@ -62,7 +62,7 @@ class NodeScopingTest {
                                 pred predicate(node a) <-> node(b).
                                 predicate(b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), hasItems("b"));
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.node("b")));
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("b")));
@@ -77,7 +77,7 @@ class NodeScopingTest {
                                 predicate({PARAM}a, {PARAM}a).
                                 ?predicate({PARAM}a, {PARAM}b).
                                 """, qualifiedNamePrefix, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.individualNode("a")));
                 assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.individualNode("a")));
@@ -92,7 +92,7 @@ class NodeScopingTest {
                                 indiv b.
                                 pred predicate(node a) <-> node({PARAM}b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.individualNode("b")));
         }
@@ -109,7 +109,7 @@ class NodeScopingTest {
                                 pred predicate(node x) <-> node(x).
                                 predicate({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.builtin().findClass("int").get().getNewNode()));
         }
@@ -121,7 +121,7 @@ class NodeScopingTest {
                 var problem = parse("""
                                 pred predicate(node x) <-> node({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.builtin().findClass("int").get().getNewNode()));
@@ -139,7 +139,7 @@ class NodeScopingTest {
                                 pred predicate(node x) <-> node(x).
                                 predicate({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findClass("Foo").get().getNewNode()));
         }
@@ -151,7 +151,7 @@ class NodeScopingTest {
                                 class Foo.
                                 pred predicate(node x) <-> node({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.findClass("Foo").get().getNewNode()));
@@ -169,7 +169,7 @@ class NodeScopingTest {
                                 pred predicate(node x) <-> node(x).
                                 predicate(new).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), hasItems("new"));
                 assertThat(problem.assertion(0).arg(0).node(), not(equalTo(problem.findClass("Foo").get().getNewNode())));
         }
@@ -182,7 +182,7 @@ class NodeScopingTest {
                                 pred predicate(Foo a) <-> node(a).
                                 predicate({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findEnum("Foo").literal("alpha")));
         }
@@ -194,7 +194,7 @@ class NodeScopingTest {
                                 enum Foo { alpha, beta }
                                 pred predicate(Foo a) <-> node({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.findEnum("Foo").literal("alpha")));
@@ -214,7 +214,7 @@ class NodeScopingTest {
                                 pred predicate(node a) <-> node(a).
                                 predicate({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.builtin().findEnum("bool").literal("true")));
         }
@@ -226,7 +226,7 @@ class NodeScopingTest {
                 var problem = parse("""
                                 pred predicate() <-> node({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.builtin().findEnum("bool").literal("true")));
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/MultiplicityValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/MultiplicityValidationTest.java
new file mode 100644
index 00000000..a8bcb1a6
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/MultiplicityValidationTest.java
@@ -0,0 +1,119 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.tests.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.validation.ProblemValidator;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class MultiplicityValidationTest {
+        @Inject
+        private ProblemParseHelper parseHelper;
+
+        @ParameterizedTest
+        @ValueSource(strings = {"2..5", "2..2", "2..*", "2", ""})
+        void validReferenceMultiplicityTest(String range) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar[%s] bar
+                                }
+
+                                class Bar.
+                                """.formatted(range));
+                assertThat(problem.validate(), empty());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"2..5", "2..2", "2..*", "2", "0..0", "0"})
+        void validScopeMultiplicityTest(String range) {
+                var problem = parseHelper.parse("""
+                                class Foo.
+
+                                scope Foo = %s.
+                                """.formatted(range));
+                assertThat(problem.validate(), empty());
+        }
+
+
+        @ParameterizedTest
+        @ValueSource(strings = {"0", "0..0"})
+        void zeroMReferenceMultiplicityTest(String range) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar[%s] bar
+                                }
+
+                                class Bar.
+                                """.formatted(range));
+                assertThat(problem.validate(), hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.WARNING)),
+                                hasProperty("issueCode", is(ProblemValidator.ZERO_MULTIPLICITY_ISSUE))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                        "container Bar bar opposite foo",
+                        "container Bar[0..1] bar opposite foo",
+                        "container Bar bar", // Invalid, but has valid multiplicity.
+                        "container Bar[0..1] bar", // Invalid, but has valid multiplicity.
+                        "Bar bar opposite foo",
+                        "Bar[0..1] bar opposite foo"
+        })
+        void validContainerReference(String referenceText) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        %s
+                                }
+
+                                class Bar {
+                                        contains Foo foo opposite bar
+                                }
+                                """.formatted(referenceText));
+                assertThat(problem.validate(), not(hasItem(hasProperty("issueCode",
+                                is(ProblemValidator.INVALID_MULTIPLICITY_ISSUE)))));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                        "container Bar[1] bar opposite foo",
+                        "container Bar[1..2] bar opposite foo",
+                        "container Bar[] bar opposite foo",
+                        "container Bar[1] bar", // Also otherwise invalid, because the {@code opposite} is missing.
+                        "container Bar[1..2] bar", // Also otherwise invalid, because the {@code opposite} is missing.
+                        "container Bar[] bar", // Also otherwise invalid, because the {@code opposite} is missing.
+                        "Bar[1] bar opposite foo",
+                        "Bar[1..2] bar opposite foo",
+                        "Bar[] bar opposite foo"
+        })
+        void invalidContainerReference(String referenceText) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        %s
+                                }
+
+                                class Bar {
+                                        contains Foo foo opposite bar
+                                }
+                                """.formatted(referenceText));
+                assertThat(problem.validate(), hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_MULTIPLICITY_ISSUE))
+                )));
+        }
+}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/OppositeValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/OppositeValidationTest.java
new file mode 100644
index 00000000..57602377
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/OppositeValidationTest.java
@@ -0,0 +1,209 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.tests.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.validation.ProblemValidator;
+
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class OppositeValidationTest {
+        @Inject
+        private ProblemParseHelper parseHelper;
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        class Foo {
+                                Bar bar opposite foo
+                        }
+
+                        class Bar {
+                                Foo foo opposite bar
+                        }
+                        """, """
+                        class Foo {
+                                contains Bar bar opposite foo
+                        }
+
+                        class Bar {
+                                Foo foo opposite bar
+                        }
+                        """, """
+                        class Foo {
+                                contains Bar bar opposite foo
+                        }
+
+                        class Bar {
+                                container Foo foo opposite bar
+                        }
+                        """, """
+                        class Foo {
+                                Foo foo[] opposite foo
+                        }
+                        """})
+        void validOppositeTest(String text) {
+                var problem = parseHelper.parse(text);
+                var issues = problem.validate();
+                assertThat(issues, not(hasItems(hasProperty("issueCode", in(Set.of(
+                                ProblemValidator.INVALID_OPPOSITE_ISSUE,
+                                ProblemValidator.MISSING_OPPOSITE_ISSUE
+                ))))));
+        }
+
+        @Test
+        void missingOppositeTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        Foo foo
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItems(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                ), allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.MISSING_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("bar", "foo"))
+                )));
+        }
+
+        @Test
+        void oppositeMismatchTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar bar opposite foo
+                                        Bar quux opposite foo
+                                }
+
+                                class Bar {
+                                        Foo foo opposite bar
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "quux", "bar"))
+                )));
+        }
+
+        @Test
+        void oppositeMismatchProxyTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        Foo foo opposite quux
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", allOf(
+                                                stringContainsInOrder("foo", "bar"),
+                                                not(containsString("null"))
+                                ))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"contains", "container"})
+        void containmentWithProxyOppositeTest(String keyword) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        %s Bar bar opposite foo
+                                }
+
+                                class Bar.
+                                """.formatted(keyword));
+                var issues = problem.validate();
+                assertThat(issues, not(hasItem(hasProperty("issueCode",
+                                is(ProblemValidator.INVALID_OPPOSITE_ISSUE)))));
+        }
+
+        @Test
+        void containmentWithContainmentOppositeTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        contains Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        contains Foo foo opposite bar
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItems(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                ), allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                )));
+        }
+
+        @Test
+        void containerWithoutOppositeTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        container Bar bar
+                                }
+
+                                class Bar.
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.MISSING_OPPOSITE_ISSUE)),
+                                hasProperty("message", containsString("bar"))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"Foo foo", "container Foo foo"})
+        void containerInvalidOppositeTest(String reference) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        container Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        %s opposite bar
+                                }
+                                """.formatted(reference));
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                )));
+        }
+}
diff --git a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java
index 6f6a87f7..f1535716 100644
--- a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java
+++ b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java
@@ -5,23 +5,26 @@
  */
 package tools.refinery.language.model.tests.utils;
 
-import org.eclipse.xtext.testing.util.ParseHelper;
-
 import com.google.inject.Inject;
-
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.testing.util.ParseHelper;
+import org.eclipse.xtext.validation.IResourceValidator;
 import tools.refinery.language.model.problem.Problem;
 
 public class ProblemParseHelper {
         @Inject
+        private IResourceValidator resourceValidator;
+        @Inject
         private ParseHelper<Problem> parseHelper;
-        
+
         public WrappedProblem parse(String text) {
                 Problem problem;
                 try {
                         problem = parseHelper.parse(text);
                 } catch (Exception e) {
-                        throw new RuntimeException("Unexpected exception while parsing Problem", e);
+                        throw new AssertionError("Unexpected exception while parsing Problem", e);
                 }
+                EcoreUtil.resolveAll(problem);
                 return new WrappedProblem(problem);
         }
 }
diff --git a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java
index e5aa0043..fc51ff57 100644
--- a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java
+++ b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java
@@ -6,7 +6,7 @@
 package tools.refinery.language.model.tests.utils;
 
 import org.eclipse.emf.ecore.resource.Resource.Diagnostic;
-import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.util.Diagnostician;
 import tools.refinery.language.model.problem.*;
 import tools.refinery.language.utils.BuiltinSymbols;
 import tools.refinery.language.utils.ProblemDesugarer;
@@ -19,11 +19,18 @@ public record WrappedProblem(Problem problem) {
                 return problem;
         }
 
-        public List<Diagnostic> errors() {
-                EcoreUtil.resolveAll(problem);
+        public List<Diagnostic> getResourceErrors() {
                 return problem.eResource().getErrors();
         }
 
+        public List<Diagnostic> getResourceWarnings() {
+                return problem.eResource().getWarnings();
+        }
+
+        public List<org.eclipse.emf.common.util.Diagnostic> validate() {
+                return Diagnostician.INSTANCE.validate(problem).getChildren();
+        }
+
         public WrappedProblem builtin() {
                 return new WrappedProblem(new ProblemDesugarer().getBuiltinProblem(problem).orElseThrow());
         }