Merge pull request #60 from kris7t/rules

Refinement rule support

18 files changed, 488 insertions, 158 deletions

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 08f7a585..10e994a0 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -18,7 +18,7 @@ enum ModuleKind:
 Statement:
         ImportStatement | Assertion | ClassDeclaration | EnumDeclaration |
         DatatypeDeclaration | AggregatorDeclaration | PredicateDefinition |
-        /* FunctionDefinition | RuleDefinition | */
+        /* FunctionDefinition | */ RuleDefinition |
         ScopeDeclaration | NodeDeclaration;
 
 ImportStatement:
@@ -45,7 +45,7 @@ AggregatorDeclaration:
         "extern" "aggregator" name=Identifier ".";
 
 enum ReferenceKind:
-        REFERENCE="refers" | CONTAINMENT="contains" | CONTAINER="container";
+        REFERENCE="refers" | CONTAINMENT="contains" | CONTAINER="container" | PARTIAL="partial";
 
 ReferenceDeclaration:
         (referenceType=[Relation|NonContainmentQualifiedName] |
@@ -75,35 +75,40 @@ Conjunction:
 //
 //Case:
 //      Conjunction ({Match.condition=current} "->" value=Expr)?;
-//RuleDefinition:
-//      "rule"
-//      name=Identifier
-//      "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")"
-//      (":" preconditions+=Conjunction (";" preconditions+=Conjunction)*)?
-//      "==>" consequents+=Consequent (";" consequents+=Consequent)*)?
-//      ".";
+
+enum RuleKind:
+        DECISION="decision" | PROPAGATION="propagation";
+
+RuleDefinition:
+        kind=RuleKind? "rule"
+        name=Identifier
+        "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")"
+        ("<->" preconditions+=Conjunction (";" preconditions+=Conjunction)*)?
+        ("==>" consequents+=Consequent (";" consequents+=Consequent)*)?
+        ".";
+
+enum ParameterBinding:
+        FOCUS="&" | MULTI="*";
 
 Parameter:
-        parameterType=[Relation|QualifiedName]? name=Identifier;
+        (
+                (concreteness=Concreteness? modality=Modality)?
+                parameterType=[Relation|QualifiedName]
+        )? binding=ParameterBinding? name=Identifier;
 
-//Consequent:
-//      actions+=Action ("," actions+=Action)*;
-//
-//Action:
-//      AssertionAction | DeleteAction | NewAction;
-//
-//AssertionAction:
-//      value=ShortLogicValue? atom=Atom |
-//      atom=Atom (overwrite?=":=" | "<:") value=LogicValue;
-//
-//DeleteAction:
-//      "delete" variableOrNode=[VariableOrNode|QualifiedName];
-//
-//NewAction:
-//      "new" variable=NewVariable ("<:" parent=[VariableOrNode|QualifiedName])?;
-//
-//NewVariable:
-//      name=Identifier;
+Consequent:
+        actions+=Action ("," actions+=Action)*;
+
+Action:
+        AssertionAction;
+
+AssertionAction:
+        relation=[Relation|QualifiedName]
+        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")"
+        ":" value=Expr |
+        value=ShortLogicConstant
+        relation=[Relation|QualifiedName]
+        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")";
 
 Expr:
         AssignmentExpr;
@@ -159,7 +164,7 @@ RangeExpr returns Expr:
 
 UnaryExpr returns Expr:
         ArithmeticUnaryExpr | NegationExpr |
-        CountExpr | AggregationExpr | CastExpr;
+        CountExpr | AggregationExpr | ModalExpr | CastExpr;
 
 enum UnaryOp:
         PLUS="+" | MINUS="-";
@@ -177,6 +182,15 @@ AggregationExpr:
         aggregator=[AggregatorDeclaration|QualifiedName]
         "{" value=Expr "|" condition=ComparisonExpr "}";
 
+enum Concreteness:
+        CANDIDATE="candidate";
+
+enum Modality:
+        MUST="must" | MAY="may";
+
+ModalExpr:
+        concreteness=Concreteness? modality=Modality body=UnaryExpr;
+
 CastExpr returns Expr:
         CastExprBody ({CastExpr.body=current} "as" targetType=[Relation|QualifiedName])?;
 
@@ -281,7 +295,7 @@ Identifier:
 
 NonContainmentIdentifier:
         ID | "atom" | "multi" | "contained" | "problem" | "module" |
-        "datatype" | "aggregator";
+        "datatype" | "aggregator" | "decision" | "propagation";
 
 Real returns ecore::EDouble:
         EXPONENTIAL | INT "." (INT | EXPONENTIAL);
diff --git a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
index d6ece1ea..c6fca89a 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
@@ -35,7 +35,7 @@ public class ProblemFormatter extends AbstractJavaFormatter {
                 surroundNewLines(doc, assertion, this::singleNewLine);
                 var region = regionFor(assertion);
                 doc.append(region.feature(ProblemPackage.Literals.ASSERTION__DEFAULT), this::oneSpace);
-                doc.append(region.feature(ProblemPackage.Literals.ASSERTION__RELATION), this::noSpace);
+                doc.append(region.feature(ProblemPackage.Literals.ABSTRACT_ASSERTION__RELATION), this::noSpace);
                 formatParenthesizedList(region, doc);
                 for (var argument : assertion.getArguments()) {
                         doc.format(argument);
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
index 8fd60364..505c7787 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
@@ -154,6 +154,9 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                         if (ProblemUtil.isTypeLike(relation)) {
                                 builder.put(TYPE_LIKE, TYPE_LIKE_TRUE);
                         }
+                } else if (eObject instanceof RuleDefinition) {
+                        // Rule definitions and predicates live in the same namespace.
+                        builder.put(SHADOWING_KEY, SHADOWING_KEY_RELATION);
                 } else if (eObject instanceof AggregatorDeclaration) {
                         builder.put(SHADOWING_KEY, SHADOWING_KEY_AGGREGATOR);
                 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java
index d94c9a13..21f64236 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java
@@ -31,11 +31,11 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
         public IScope getScope(EObject context, EReference reference) {
                 var scope = super.getScope(context, reference);
                 if (reference == ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE) {
-                        return getNodesScope(context, scope);
+                        // On the right side of a rule, assertion arguments may refer to variables.
+                        var rule = EcoreUtil2.getContainerOfType(context, RuleDefinition.class);
+                        return rule == null ? getNodesScope(context, scope) : getVariableScope(context, scope);
                 }
-                if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE
-                                || reference == ProblemPackage.Literals.NEW_ACTION__PARENT
-                                || reference == ProblemPackage.Literals.DELETE_ACTION__VARIABLE_OR_NODE) {
+                if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE) {
                         return getVariableScope(context, scope);
                 }
                 if (reference == ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE) {
@@ -81,13 +81,6 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
                 switch (currentContext) {
                 case ExistentialQuantifier quantifier -> variables.addAll(quantifier.getImplicitVariables());
                 case Match match -> variables.addAll(match.getCondition().getImplicitVariables());
-                case Consequent consequent -> {
-                        for (var literal : consequent.getActions()) {
-                                if (literal instanceof NewAction newAction && newAction.getVariable() != null) {
-                                        variables.add(newAction.getVariable());
-                                }
-                        }
-                }
                 default -> {
                         // Nothing to add.
                 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java b/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java
index 3432b2d8..225bf49d 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java
@@ -12,9 +12,11 @@ import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransi
 import tools.refinery.language.model.problem.Assertion;
 import tools.refinery.language.model.problem.LogicConstant;
 import tools.refinery.language.model.problem.LogicValue;
-import tools.refinery.language.model.problem.ProblemPackage;
 import tools.refinery.language.services.ProblemGrammarAccess;
 
+import static tools.refinery.language.model.problem.ProblemPackage.Literals.ABSTRACT_ASSERTION__ARGUMENTS;
+import static tools.refinery.language.model.problem.ProblemPackage.Literals.ABSTRACT_ASSERTION__RELATION;
+
 public class PreferShortAssertionsProblemSemanticSequencer extends ProblemSemanticSequencer {
         @Inject
         private ProblemGrammarAccess grammarAccess;
@@ -27,13 +29,13 @@ public class PreferShortAssertionsProblemSemanticSequencer extends ProblemSemant
                         return;
                 }
                 if (errorAcceptor != null) {
-                        if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.ASSERTION__RELATION) == ValueTransient.YES) {
+                        if (transientValues.isValueTransient(semanticObject, ABSTRACT_ASSERTION__RELATION) == ValueTransient.YES) {
                                 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject,
-                                                ProblemPackage.Literals.ASSERTION__RELATION));
+                                                ABSTRACT_ASSERTION__RELATION));
                         }
-                        if (transientValues.isListTransient(semanticObject, ProblemPackage.Literals.ASSERTION__ARGUMENTS) == ListTransient.YES) {
+                        if (transientValues.isListTransient(semanticObject, ABSTRACT_ASSERTION__ARGUMENTS) == ListTransient.YES) {
                                 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject,
-                                                ProblemPackage.Literals.ASSERTION__ARGUMENTS));
+                                                ABSTRACT_ASSERTION__ARGUMENTS));
                         }
                 }
                 var feeder = createSequencerFeeder(context, semanticObject);
diff --git a/subprojects/language/src/main/java/tools/refinery/language/typesystem/ExprType.java b/subprojects/language/src/main/java/tools/refinery/language/typesystem/ExprType.java
index 9e44063d..65721924 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/typesystem/ExprType.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/typesystem/ExprType.java
@@ -8,6 +8,7 @@ package tools.refinery.language.typesystem;
 public sealed interface ExprType permits FixedType, MutableType {
         NodeType NODE = new NodeType();
         LiteralType LITERAL = new LiteralType();
+        ModalLiteralType MODAL_LITERAL = new ModalLiteralType();
         InvalidType INVALID = new InvalidType();
 
         FixedType getActualType();
diff --git a/subprojects/language/src/main/java/tools/refinery/language/typesystem/FixedType.java b/subprojects/language/src/main/java/tools/refinery/language/typesystem/FixedType.java
index 1b2ded48..f9e75f26 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/typesystem/FixedType.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/typesystem/FixedType.java
@@ -5,7 +5,8 @@
  */
 package tools.refinery.language.typesystem;
 
-public sealed interface FixedType extends ExprType permits NodeType, LiteralType, InvalidType, DataExprType {
+public sealed interface FixedType extends ExprType permits NodeType, LiteralType, ModalLiteralType, InvalidType,
+                DataExprType {
         @Override
         default FixedType getActualType() {
                 return this;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/typesystem/ModalLiteralType.java b/subprojects/language/src/main/java/tools/refinery/language/typesystem/ModalLiteralType.java
new file mode 100644
index 00000000..6b44977a
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/typesystem/ModalLiteralType.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.typesystem;
+
+public final class ModalLiteralType implements FixedType {
+        ModalLiteralType() {
+        }
+
+        @Override
+        public String toString() {
+                return "modal constraint";
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/typesystem/TypedModule.java b/subprojects/language/src/main/java/tools/refinery/language/typesystem/TypedModule.java
index 6691f0ae..63815506 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/typesystem/TypedModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/typesystem/TypedModule.java
@@ -63,6 +63,7 @@ public class TypedModule {
                 for (var statement : problem.getStatements()) {
                         switch (statement) {
                         case PredicateDefinition predicateDefinition -> checkTypes(predicateDefinition);
+                        case RuleDefinition ruleDefinition -> checkTypes(ruleDefinition);
                         case Assertion assertion -> checkTypes(assertion);
                         default -> {
                                 // Nothing to type check.
@@ -79,13 +80,33 @@ public class TypedModule {
                 }
         }
 
+        private void checkTypes(RuleDefinition ruleDefinition) {
+                for (var conjunction : ruleDefinition.getPreconditions()) {
+                        for (var literal : conjunction.getLiterals()) {
+                                expectType(literal, ExprType.MODAL_LITERAL);
+                        }
+                }
+                for (var consequent : ruleDefinition.getConsequents()) {
+                        for (var action : consequent.getActions()) {
+                                if (action instanceof AssertionAction assertionAction) {
+                                        checkTypes(assertionAction);
+                                }
+                        }
+                }
+        }
+
         private void checkTypes(Assertion assertion) {
+                checkAssertionValueType(assertion);
+                checkNodeAssertionArgumentTypes(assertion, false);
+        }
+
+        private void checkAssertionValueType(AbstractAssertion assertion) {
                 var relation = assertion.getRelation();
-                var value = assertion.getValue();
                 if (relation == null) {
                         return;
                 }
                 var type = signatureProvider.getSignature(relation).resultType();
+                var value = assertion.getValue();
                 if (type == ExprType.LITERAL) {
                         if (value == null) {
                                 return;
@@ -95,11 +116,43 @@ public class TypedModule {
                 }
                 if (value == null) {
                         var message = "Assertion value of type %s is required.".formatted(type);
-                        error(message, assertion, ProblemPackage.Literals.ASSERTION__RELATION, 0, ProblemValidator.TYPE_ERROR);
+                        error(message, assertion, ProblemPackage.Literals.ABSTRACT_ASSERTION__VALUE, 0,
+                    ProblemValidator.TYPE_ERROR);
                 }
                 expectType(value, type);
         }
 
+        private void checkNodeAssertionArgumentTypes(AbstractAssertion assertion, boolean allowVariables) {
+                for (var argument : assertion.getArguments()) {
+                        if (argument instanceof NodeAssertionArgument nodeAssertionArgument) {
+                                checkNodeAssertionArgumentType(nodeAssertionArgument, allowVariables);
+                        }
+                }
+        }
+
+        private void checkNodeAssertionArgumentType(NodeAssertionArgument nodeAssertionArgument, boolean allowVariables) {
+                var variableOrNode = nodeAssertionArgument.getNode();
+                if (variableOrNode == null || variableOrNode.eIsProxy()) {
+                        return;
+                }
+                if (allowVariables && variableOrNode instanceof Variable variable) {
+                        var variableType = getVariableType(variable);
+                        if (variableType == ExprType.INVALID || variableType == ExprType.NODE) {
+                                return;
+                        }
+                }
+                if (variableOrNode instanceof Node) {
+                        return;
+                }
+                error("Assertion argument must be a node.", nodeAssertionArgument,
+                                ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE, 0, ProblemValidator.TYPE_ERROR);
+        }
+
+        private void checkTypes(AssertionAction assertionAction) {
+                checkAssertionValueType(assertionAction);
+                checkNodeAssertionArgumentTypes(assertionAction, true);
+        }
+
         public List<FeatureBasedDiagnostic> getDiagnostics() {
                 return diagnostics;
         }
@@ -202,6 +255,7 @@ public class TypedModule {
                         case RangeExpr rangeExpr -> computeExpressionType(rangeExpr);
                         case ArithmeticBinaryExpr arithmeticBinaryExpr -> computeExpressionType(arithmeticBinaryExpr);
                         case CastExpr castExpr -> computeExpressionType(castExpr);
+                        case ModalExpr modalExpr -> computeExpressionType(modalExpr);
                         default -> {
                                 error("Unknown expression: " + expr.getClass().getSimpleName(), expr, null, 0,
                                                 ProblemValidator.UNKNOWN_EXPRESSION_ISSUE);
@@ -290,6 +344,9 @@ public class TypedModule {
                         // Negation of literals yields another (non-enumerable) literal.
                         return ExprType.LITERAL;
                 }
+                if (actualType == ExprType.MODAL_LITERAL) {
+                        return ExprType.MODAL_LITERAL;
+                }
                 if (actualType == ExprType.INVALID) {
                         return ExprType.INVALID;
                 }
@@ -507,6 +564,28 @@ public class TypedModule {
                 return ExprType.INVALID;
         }
 
+        @NotNull
+        private ExprType computeExpressionType(ModalExpr expr) {
+                var body = expr.getBody();
+                if (body == null) {
+                        return ExprType.INVALID;
+                }
+                var actualType = getExpressionType(body);
+                if (actualType == ExprType.LITERAL || BuiltinTermInterpreter.BOOLEAN_TYPE.equals(actualType)) {
+                        return ExprType.MODAL_LITERAL;
+                }
+                if (actualType == ExprType.INVALID) {
+                        return ExprType.INVALID;
+                }
+                if (actualType instanceof MutableType) {
+                        error(OPERAND_TYPE_ERROR_MESSAGE, body, null, 0, ProblemValidator.TYPE_ERROR);
+                        return ExprType.INVALID;
+                }
+                var message = "Data type %s does not support modal operators.".formatted(actualType);
+                error(message, expr, null, 0, ProblemValidator.TYPE_ERROR);
+                return ExprType.INVALID;
+        }
+
         private FixedType getCommonDataType(BinaryExpr expr) {
                 var commonType = getCommonType(expr);
                 if (!(commonType instanceof DataExprType) && commonType != ExprType.INVALID) {
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 9daa8f61..e1820261 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
@@ -42,13 +42,11 @@ public final class ProblemUtil {
         }
 
         public static boolean isImplicit(EObject eObject) {
-                if (eObject instanceof Node node) {
-                        return isImplicitNode(node);
-                } else if (eObject instanceof Variable variable) {
-                        return isImplicitVariable(variable);
-                } else {
-                        return false;
-                }
+                return switch (eObject) {
+                        case Node node -> isImplicitNode(node);
+                        case Variable variable -> isImplicitVariable(variable);
+                        default -> false;
+                };
         }
 
         public static boolean isError(EObject eObject) {
@@ -119,7 +117,7 @@ public final class ProblemUtil {
                         return false;
                 }
                 return switch (kind) {
-                        case CONTAINMENT -> false;
+                        case CONTAINMENT, PARTIAL -> false;
                         case CONTAINER -> true;
                         case DEFAULT, REFERENCE -> {
                                 var opposite = referenceDeclaration.getOpposite();
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ActionTargetCollector.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ActionTargetCollector.java
new file mode 100644
index 00000000..67cd5777
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ActionTargetCollector.java
@@ -0,0 +1,73 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.validation;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import org.eclipse.xtext.util.Tuples;
+import tools.refinery.language.model.problem.*;
+
+import java.util.HashSet;
+import java.util.Set;
+
+@Singleton
+public class ActionTargetCollector {
+        private static final String ACTION_TARGETS =
+                        "tools.refinery.language.validation.ActionTargetCollector.ACTION_TARGETS";
+
+        @Inject
+        private IResourceScopeCache cache = IResourceScopeCache.NullImpl.INSTANCE;
+
+        public boolean isActionTarget(Relation relation) {
+                var problem = EcoreUtil2.getContainerOfType(relation, Problem.class);
+                return problem != null && isActionTarget(problem, relation);
+        }
+
+        public boolean isActionTarget(Problem problem, Relation relation) {
+                var targets = getActionTargets(problem);
+                if (targets.contains(relation)) {
+                        return true;
+                }
+                if (relation instanceof ReferenceDeclaration referenceDeclaration) {
+                        var opposite = referenceDeclaration.getOpposite();
+                        return opposite != null && targets.contains(opposite);
+                }
+                return false;
+        }
+
+        protected Set<Relation> getActionTargets(Problem problem) {
+                var resource = problem.eResource();
+                if (resource == null) {
+                        return doGetActionTargets(problem);
+                }
+                return cache.get(Tuples.create(problem, ACTION_TARGETS), resource, () -> doGetActionTargets(problem));
+        }
+
+        protected Set<Relation> doGetActionTargets(Problem problem) {
+                var targets = new HashSet<Relation>();
+                for (var statement : problem.getStatements()) {
+                        if (statement instanceof RuleDefinition ruleDefinition) {
+                                collectTargets(ruleDefinition, targets);
+                        }
+                }
+                return targets;
+        }
+
+        private static void collectTargets(RuleDefinition ruleDefinition, HashSet<Relation> targets) {
+                for (var consequent : ruleDefinition.getConsequents()) {
+                        for (var action : consequent.getActions()) {
+                                if (action instanceof AssertionAction assertionAction) {
+                                        var target = assertionAction.getRelation();
+                                        if (target != null) {
+                                                targets.add(target);
+                                        }
+                                }
+                        }
+                }
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ExistsVariableCollector.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ExistsVariableCollector.java
new file mode 100644
index 00000000..5812bdc4
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ExistsVariableCollector.java
@@ -0,0 +1,75 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.validation;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import org.eclipse.xtext.util.Tuples;
+import tools.refinery.language.model.problem.*;
+import tools.refinery.language.scoping.imports.ImportAdapterProvider;
+import tools.refinery.language.utils.ProblemUtil;
+
+import java.util.HashSet;
+import java.util.Set;
+
+@Singleton
+public class ExistsVariableCollector {
+        private static final String EXISTS_VARIABLES =
+                        "tools.refinery.language.validation.ExistsVariableCollector.EXISTS_VARIABLES";
+
+        @Inject
+        private IResourceScopeCache cache = IResourceScopeCache.NullImpl.INSTANCE;
+
+        @Inject
+        private ImportAdapterProvider importAdapterProvider;
+
+        public boolean missingExistsConstraint(Variable variable) {
+                if (variable instanceof Parameter) {
+                        return false;
+                }
+                if (ProblemUtil.isImplicitVariable(variable)) {
+                        var negation = EcoreUtil2.getContainerOfType(variable, NegationExpr.class);
+                        if (negation != null) {
+                                // Negations are implicitly quantified.
+                                return false;
+                        }
+                }
+                var conjunction = EcoreUtil2.getContainerOfType(variable, Conjunction.class);
+                if (conjunction == null) {
+                        return true;
+                }
+                var variables = getExistsVariables(conjunction);
+                return !variables.contains(variable);
+        }
+
+        protected Set<Variable> getExistsVariables(Conjunction conjunction) {
+                var resource = conjunction.eResource();
+                if (resource == null) {
+                        return doGetExistsVariables(conjunction);
+                }
+                return cache.get(Tuples.create(conjunction, EXISTS_VARIABLES), resource,
+                                () -> doGetExistsVariables(conjunction));
+        }
+
+        protected Set<Variable> doGetExistsVariables(Conjunction conjunction) {
+                var builtinSymbols = importAdapterProvider.getBuiltinSymbols(conjunction);
+                var existsRelation = builtinSymbols.exists();
+                var set = new HashSet<Variable>();
+                for (var atom : EcoreUtil2.getAllContentsOfType(conjunction, Atom.class)) {
+                        if (existsRelation.equals(atom.getRelation())) {
+                                for (var argument : atom.getArguments()) {
+                                        if (argument instanceof VariableOrNodeExpr variableOrNodeExpr &&
+                                                        variableOrNodeExpr.getVariableOrNode() instanceof Variable variable) {
+                                                set.add(variable);
+                                        }
+                                }
+                        }
+                }
+                return set;
+        }
+}
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 745e2d2b..84218f17 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
@@ -24,10 +24,7 @@ import tools.refinery.language.typesystem.ProblemTypeAnalyzer;
 import tools.refinery.language.typesystem.SignatureProvider;
 import tools.refinery.language.utils.ProblemUtil;
 
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.Set;
+import java.util.*;
 
 /**
  * This class contains custom validation rules.
@@ -49,17 +46,26 @@ public class ProblemValidator extends AbstractProblemValidator {
         public static final String INVALID_SUPERTYPE_ISSUE = ISSUE_PREFIX + "INVALID_SUPERTYPE";
         public static final String INVALID_REFERENCE_TYPE_ISSUE = ISSUE_PREFIX + "INVALID_REFERENCE_TYPE";
         public static final String INVALID_ARITY_ISSUE = ISSUE_PREFIX + "INVALID_ARITY";
+        public static final String INVALID_MODALITY_ISSUE = ISSUE_PREFIX + "INVALID_MODALITY";
+        public static final String INVALID_RULE_ISSUE = ISSUE_PREFIX + "INVALID_RULE";
         public static final String INVALID_TRANSITIVE_CLOSURE_ISSUE = ISSUE_PREFIX + "INVALID_TRANSITIVE_CLOSURE";
-        public static final String INVALID_VALUE_ISSUE = ISSUE_PREFIX + "INVALID_VALUE";
         public static final String UNSUPPORTED_ASSERTION_ISSUE = ISSUE_PREFIX + "UNSUPPORTED_ASSERTION";
         public static final String UNKNOWN_EXPRESSION_ISSUE = ISSUE_PREFIX + "UNKNOWN_EXPRESSION";
         public static final String INVALID_ASSIGNMENT_ISSUE = ISSUE_PREFIX + "INVALID_ASSIGNMENT";
         public static final String TYPE_ERROR = ISSUE_PREFIX + "TYPE_ERROR";
+        public static final String VARIABLE_WITHOUT_EXISTS = ISSUE_PREFIX + "VARIABLE_WITHOUT_EXISTS";
+        public static final String UNUSED_PARTIAL_RELATION = ISSUE_PREFIX + "UNUSED_PARTIAL_RELATION";
 
         @Inject
         private ReferenceCounter referenceCounter;
 
         @Inject
+        private ExistsVariableCollector existsVariableCollector;
+
+        @Inject
+        private ActionTargetCollector actionTargetCollector;
+
+        @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
 
         @Inject
@@ -128,6 +134,14 @@ public class ProblemValidator extends AbstractProblemValidator {
                 var variableOrNode = expr.getVariableOrNode();
                 if (variableOrNode instanceof Variable variable && ProblemUtil.isImplicitVariable(variable)
                                 && !ProblemUtil.isSingletonVariable(variable)) {
+                        if (EcoreUtil2.getContainerOfType(variable, ParametricDefinition.class) instanceof RuleDefinition &&
+                                        EcoreUtil2.getContainerOfType(variable, NegationExpr.class) == null &&
+                                        // If there is an exists constraint, it is the only constraint.
+                                        existsVariableCollector.missingExistsConstraint(variable)) {
+                                // Existentially quantified variables in rules should not be singletons,
+                                // because we have to add an {@code exists} constraint as well.
+                                return;
+                        }
                         var problem = EcoreUtil2.getContainerOfType(variable, Problem.class);
                         if (problem != null && referenceCounter.countReferences(problem, variable) <= 1) {
                                 var name = variable.getName();
@@ -152,13 +166,32 @@ public class ProblemValidator extends AbstractProblemValidator {
         }
 
         @Check
+        public void checkNodeAssertionArgumentConstants(NodeAssertionArgument argument) {
+                var rule = EcoreUtil2.getContainerOfType(argument, RuleDefinition.class);
+                if (rule == null) {
+                        return;
+                }
+                var variableOrNode = argument.getNode();
+                if (variableOrNode instanceof Node node && !ProblemUtil.isAtomNode(node)) {
+                        var name = node.getName();
+                        var message = ("Only atoms can be referenced in rule actions. " +
+                                        "Mark '%s' as an atom with the declaration 'atom %s.'").formatted(name, name);
+                        error(message, argument, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE,
+                                        INSIGNIFICANT_INDEX, NODE_CONSTANT_ISSUE);
+                }
+        }
+
+        @Check
         public void checkUniqueDeclarations(Problem problem) {
-                var relations = new ArrayList<Relation>();
+                var relations = new ArrayList<NamedElement>();
                 var nodes = new ArrayList<Node>();
                 var aggregators = new ArrayList<AggregatorDeclaration>();
                 for (var statement : problem.getStatements()) {
                         if (statement instanceof Relation relation) {
                                 relations.add(relation);
+                        } else if (statement instanceof RuleDefinition ruleDefinition) {
+                                // Rule definitions and predicates live in the same namespace.
+                                relations.add(ruleDefinition);
                         } else if (statement instanceof NodeDeclaration nodeDeclaration) {
                                 nodes.addAll(nodeDeclaration.getNodes());
                         } else if (statement instanceof AggregatorDeclaration aggregatorDeclaration) {
@@ -298,6 +331,22 @@ public class ProblemValidator extends AbstractProblemValidator {
                                                 referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
                                                 INVALID_OPPOSITE_ISSUE);
                         }
+                } else if (kind == ReferenceKind.PARTIAL && opposite != null && opposite.getKind() != ReferenceKind.PARTIAL) {
+                        acceptError("Opposite '%s' of partial reference '%s' is not a partial reference."
+                                                        .formatted(opposite.getName(), referenceDeclaration.getName()),
+                                        referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
+                                        INVALID_OPPOSITE_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkPartialReference(ReferenceDeclaration referenceDeclaration) {
+                if (referenceDeclaration.getKind() == ReferenceKind.PARTIAL &&
+                                !actionTargetCollector.isActionTarget(referenceDeclaration)) {
+                        var message = "Add decision or propagation rules to refine partial relation '%s'."
+                                                        .formatted(referenceDeclaration.getName());
+                        acceptWarning(message, referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__KIND, 0,
+                                        UNUSED_PARTIAL_RELATION);
                 }
         }
 
@@ -336,8 +385,33 @@ public class ProblemValidator extends AbstractProblemValidator {
         }
 
         @Check
-        public void checkParameterType(Parameter parameter) {
+        public void checkParameter(Parameter parameter) {
                 checkArity(parameter, ProblemPackage.Literals.PARAMETER__PARAMETER_TYPE, 1);
+                var parametricDefinition = EcoreUtil2.getContainerOfType(parameter, ParametricDefinition.class);
+                if (parametricDefinition instanceof RuleDefinition rule) {
+                        if (parameter.getParameterType() != null && parameter.getModality() == Modality.NONE) {
+                                acceptError("Parameter type modality must be specified.", parameter,
+                                                ProblemPackage.Literals.PARAMETER__PARAMETER_TYPE, 0, INVALID_MODALITY_ISSUE);
+                        }
+                        var kind = rule.getKind();
+                        var binding = parameter.getBinding();
+                        if (kind == RuleKind.PROPAGATION && binding != ParameterBinding.SINGLE) {
+                                acceptError("Parameter binding annotations are not supported in propagation rules.", parameter,
+                                                ProblemPackage.Literals.PARAMETER__BINDING, 0, INVALID_MODALITY_ISSUE);
+                        } else if (kind != RuleKind.DECISION && binding == ParameterBinding.MULTI) {
+                                acceptError("Explicit multi-object bindings are only supported in decision rules.", parameter,
+                                                ProblemPackage.Literals.PARAMETER__BINDING, 0, INVALID_MODALITY_ISSUE);
+                        }
+                } else {
+                        if (parameter.getConcreteness() != Concreteness.PARTIAL || parameter.getModality() != Modality.NONE) {
+                                acceptError("Modal parameter types are only supported in rule definitions.", parameter, null, 0,
+                                                INVALID_MODALITY_ISSUE);
+                        }
+                        if (parameter.getBinding() != ParameterBinding.SINGLE) {
+                                acceptError("Parameter binding annotations are only supported in decision rules.", parameter,
+                                                ProblemPackage.PARAMETER__BINDING, 0, INVALID_MODALITY_ISSUE);
+                        }
+                }
         }
 
         @Check
@@ -353,16 +427,46 @@ public class ProblemValidator extends AbstractProblemValidator {
         }
 
         @Check
-        public void checkAssertion(Assertion assertion) {
+        public void checkRuleDefinition(RuleDefinition ruleDefinition) {
+                if (ruleDefinition.getConsequents().size() != 1) {
+                        acceptError("Rules must have exactly one consequent.", ruleDefinition,
+                                        ProblemPackage.Literals.NAMED_ELEMENT__NAME, 0, INVALID_RULE_ISSUE);
+                }
+                var unquantifiedVariables = new HashSet<Variable>();
+                for (var variable : EcoreUtil2.getAllContentsOfType(ruleDefinition, Variable.class)) {
+                        if (existsVariableCollector.missingExistsConstraint(variable)) {
+                                unquantifiedVariables.add(variable);
+                        }
+                }
+                for (var expr : EcoreUtil2.getAllContentsOfType(ruleDefinition, VariableOrNodeExpr.class)) {
+                        if (expr.getVariableOrNode() instanceof Variable variable && unquantifiedVariables.contains(variable)) {
+                                unquantifiedVariables.remove(variable);
+                                var name = variable.getName();
+                                String message;
+                                if (ProblemUtil.isSingletonVariable(variable)) {
+                                        message = ("Remove the singleton variable marker '_' and clarify the quantification of variable " +
+                            "'%s'.").formatted(name);
+                                } else {
+                                        message = ("Add a 'must exists(%s)', 'may exists(%s)', or 'may !exists(%s)' constraint to " +
+                                                        "clarify the quantification of variable '%s'.").formatted(name, name, name, name);
+                                }
+                                acceptWarning(message, expr, ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE, 0,
+                                                VARIABLE_WITHOUT_EXISTS);
+                        }
+                }
+        }
+
+        @Check
+        public void checkAssertion(AbstractAssertion assertion) {
                 var relation = assertion.getRelation();
                 if (relation instanceof DatatypeDeclaration) {
                         var message = "Assertions for data types are not supported.";
-                        acceptError(message, assertion, ProblemPackage.Literals.ASSERTION__RELATION, 0,
+                        acceptError(message, assertion, ProblemPackage.Literals.ABSTRACT_ASSERTION__RELATION, 0,
                                         UNSUPPORTED_ASSERTION_ISSUE);
                         return;
                 }
                 int argumentCount = assertion.getArguments().size();
-                checkArity(assertion, ProblemPackage.Literals.ASSERTION__RELATION, argumentCount);
+                checkArity(assertion, ProblemPackage.Literals.ABSTRACT_ASSERTION__RELATION, argumentCount);
         }
 
         @Check
@@ -466,15 +570,17 @@ public class ProblemValidator extends AbstractProblemValidator {
 
         @Nullable
         private Node getNodeArgumentForMultiObjectAssertion(AssertionArgument argument) {
-                if (argument instanceof WildcardAssertionArgument) {
-                        acceptError("Wildcard arguments for 'exists' are not supported.", argument, null, 0,
-                                        UNSUPPORTED_ASSERTION_ISSUE);
-                        return null;
-                }
-                if (argument instanceof NodeAssertionArgument nodeAssertionArgument) {
-                        return nodeAssertionArgument.getNode();
-                }
-                throw new IllegalArgumentException("Unknown assertion argument: " + argument);
+                return switch (argument) {
+                        case null -> null;
+                        case WildcardAssertionArgument ignoredWildcardAssertionArgument -> {
+                                acceptError("Wildcard arguments for 'exists' are not supported.", argument, null, 0,
+                                                UNSUPPORTED_ASSERTION_ISSUE);
+                                yield null;
+                        }
+                        case NodeAssertionArgument nodeAssertionArgument ->
+                                        nodeAssertionArgument.getNode() instanceof Node node ? node : null;
+                        default -> throw new IllegalArgumentException("Unknown assertion argument: " + argument);
+                };
         }
 
         @Check
@@ -484,8 +590,10 @@ public class ProblemValidator extends AbstractProblemValidator {
                 }
                 for (var argument : assertion.getArguments()) {
                         if (argument instanceof NodeAssertionArgument nodeAssertionArgument) {
-                                var node = nodeAssertionArgument.getNode();
-                                if (node != null && !node.eIsProxy() && ProblemUtil.isImplicitNode(node)) {
+                                var variableOrNode = nodeAssertionArgument.getNode();
+                                if (variableOrNode instanceof Node node &&
+                                                !variableOrNode.eIsProxy() &&
+                                                ProblemUtil.isImplicitNode(node)) {
                                         var name = node.getName();
                                         var message = ("Implicit nodes are not allowed in modules. Explicitly declare '%s' as a node " +
                                                         "with the declaration 'declare %s.'").formatted(name, name);
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ReferenceCounter.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ReferenceCounter.java
index 55cbd71d..40781168 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/validation/ReferenceCounter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ReferenceCounter.java
@@ -5,20 +5,21 @@
  */
 package tools.refinery.language.validation;
 
-import java.util.HashMap;
-import java.util.Map;
-
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.util.IResourceScopeCache;
 import org.eclipse.xtext.util.Tuples;
-
-import com.google.inject.Inject;
-import com.google.inject.Singleton;
-
 import tools.refinery.language.model.problem.Problem;
 
+import java.util.HashMap;
+import java.util.Map;
+
 @Singleton
 public class ReferenceCounter {
+        private static final String REFERENCE_COUNTS =
+                        "tools.refinery.language.validation.ReferenceCounter.REFERENCE_COUNTS";
+
         @Inject
         private IResourceScopeCache cache = IResourceScopeCache.NullImpl.INSTANCE;
 
@@ -35,7 +36,7 @@ public class ReferenceCounter {
                 if (resource == null) {
                         return doGetReferenceCounts(problem);
                 }
-                return cache.get(Tuples.create(problem, "referenceCounts"), resource, () -> doGetReferenceCounts(problem));
+                return cache.get(Tuples.create(problem, REFERENCE_COUNTS), resource, () -> doGetReferenceCounts(problem));
         }
 
         protected Map<EObject, Integer> doGetReferenceCounts(Problem problem) {
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 56e65550..15636483 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
@@ -9,7 +9,6 @@ import com.google.inject.Inject;
 import org.eclipse.xtext.testing.InjectWith;
 import org.eclipse.xtext.testing.extensions.InjectionExtension;
 import org.junit.jupiter.api.Disabled;
-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;
@@ -17,7 +16,7 @@ import tools.refinery.language.model.tests.utils.ProblemParseHelper;
 import tools.refinery.language.tests.ProblemInjectorProvider;
 
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.*;
+import static org.hamcrest.Matchers.empty;
 
 @Disabled("TODO: Rework transformation rules")
 @ExtendWith(InjectionExtension.class)
@@ -29,62 +28,13 @@ class RuleParsingTest {
         @ParameterizedTest
         @ValueSource(strings = { """
                         pred Person(p).
-                        rule r(p1): must Person(p1) ==> Person(p1) := false.
-                        """, """
-                        pred Person(p).
-                        rule r(p1): must Person(p1) ==> Person(p1) <: false.
+                        rule r(p1): must Person(p1) ==> Person(p1): false.
                         """, """
                         pred Person(p).
                         rule r(p1): must Person(p1) ==> !Person(p1).
-                        """, """
-                        pred Person(p).
-                        rule r(p1): must Person(p1) ==> delete p1.
                         """ })
         void simpleTest(String text) {
                 var problem = parseHelper.parse(text);
                 assertThat(problem.getResourceErrors(), empty());
         }
-
-        @Test
-        void newNodeTest() {
-                var problem = parseHelper.parse("""
-                                pred Person(p).
-                                rule r(p1): must Person(p1) ==> new p2, Person(p2) := unknown.
-                                """);
-                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()));
-        }
-
-        @Test
-        void differentScopeTest() {
-                var problem = parseHelper.parse("""
-                                pred Friend(a, b).
-                                rule r(p1): !may Friend(p1, p2) ==> new p2, Friend(p1, p2) := true.
-                                """);
-                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())));
-        }
-
-        @Test
-        void parameterShadowingTest() {
-                var problem = parseHelper.parse("""
-                                pred Friend(a, b).
-                                rule r(p1, p2): !may Friend(p1, p2) ==> new p2, Friend(p1, p2) := true.
-                                """);
-                assertThat(problem.getResourceErrors(), empty());
-                assertThat(problem.rule("r").param(1),
-                                not(equalTo(problem.rule("r").consequent(0).action(1).assertedAtom().arg(1).variable())));
-        }
-
-        @Test
-        void deleteDifferentScopeNodeTest() {
-                var problem = parseHelper.parse("""
-                                pred Person(p).
-                                rule r(p1): must Friend(p1, p2) ==> delete p2.
-                                """);
-                assertThat(problem.getResourceErrors(), not(empty()));
-        }
 }
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
index 57602377..d73ef8e7 100644
--- 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
@@ -57,6 +57,18 @@ class OppositeValidationTest {
                         class Foo {
                                 Foo foo[] opposite foo
                         }
+                        """, """
+                        class Foo {
+                                partial Bar bar opposite foo
+                        }
+
+                        class Bar {
+                                partial Foo foo opposite bar
+                        }
+                        """, """
+                        class Foo {
+                                partial Foo foo[] opposite foo
+                        }
                         """})
         void validOppositeTest(String text) {
                 var problem = parseHelper.parse(text);
@@ -188,7 +200,7 @@ class OppositeValidationTest {
         }
 
         @ParameterizedTest
-        @ValueSource(strings = {"Foo foo", "container Foo foo"})
+        @ValueSource(strings = {"Foo foo", "container Foo foo", "partial Foo foo"})
         void containerInvalidOppositeTest(String reference) {
                 var problem = parseHelper.parse("""
                                 class Foo {
@@ -203,7 +215,27 @@ class OppositeValidationTest {
                 assertThat(issues, hasItem(allOf(
                                 hasProperty("severity", is(Diagnostic.ERROR)),
                                 hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
-                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                                hasProperty("message", stringContainsInOrder("foo", "container", "bar"))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"Foo foo", "contains Foo foo", "container Foo foo"})
+        void partialWithConcreteOppositeTest(String reference) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        partial 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", "partial", "bar"))
                 )));
         }
 }
diff --git a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAction.java b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAction.java
index 3a49a0b9..4987cb89 100644
--- a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAction.java
+++ b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAction.java
@@ -6,25 +6,9 @@
 package tools.refinery.language.model.tests.utils;
 
 import tools.refinery.language.model.problem.Action;
-import tools.refinery.language.model.problem.AssertionAction;
-import tools.refinery.language.model.problem.DeleteAction;
-import tools.refinery.language.model.problem.NewAction;
-import tools.refinery.language.model.problem.VariableOrNode;
 
 public record WrappedAction(Action action) {
         public Action get() {
                 return action;
         }
-        
-        public VariableOrNode newVar() {
-                return ((NewAction) action).getVariable();
-        }
-        
-        public VariableOrNode deleteVar() {
-                return ((DeleteAction) action).getVariableOrNode();
-        }
-        
-        public WrappedAtom assertedAtom() {
-                return new WrappedAtom(((AssertionAction) action).getAtom());
-        }
 }
diff --git a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAssertionArgument.java b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAssertionArgument.java
index b36f2506..50cb958d 100644
--- a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAssertionArgument.java
+++ b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedAssertionArgument.java
@@ -15,6 +15,6 @@ public record WrappedAssertionArgument(AssertionArgument assertionArgument) {
         }
 
         public Node node() {
-                return ((NodeAssertionArgument) assertionArgument).getNode();
+                return (Node) ((NodeAssertionArgument) assertionArgument).getNode();
         }
 }