feat(language): numeric expressions

12 files changed, 560 insertions, 239 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 2a8429a3..bc1ee465 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -8,9 +8,10 @@ Problem:
         statements+=Statement*;
 
 Statement:
-        ClassDeclaration | EnumDeclaration | PredicateDefinition | /* RuleDefinition | */ Assertion | NodeValueAssertion |
-        ScopeDeclaration |
-        IndividualDeclaration;
+        ClassDeclaration | EnumDeclaration |
+        PredicateDefinition | FunctionDefinition | /* RuleDefinition | */
+        Assertion | NodeValueAssertion |
+        ScopeDeclaration | IndividualDeclaration;
 
 ClassDeclaration:
         abstract?="abstract"? "class"
@@ -30,53 +31,51 @@ enum ReferenceKind:
         REFERENCE="refers" | CONTAINMENT="contains" | CONTAINER="container";
 
 ReferenceDeclaration:
-        (
-                kind=ReferenceKind referenceType=[Relation|QualifiedName] |
-                referenceType=[Relation|NonRelationKindQualifiedName]
-        )
+        (kind=ReferenceKind referenceType=[Relation|QualifiedName] |
+        referenceType=[Relation|NonRelationKindQualifiedName])
         ("[" multiplicity=Multiplicity "]")?
         name=Identifier
         ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?;
 
+enum ErrorKind returns PredicateKind:
+        ERROR="error";
+
 enum PredicateKind:
         ERROR="error" | CONTAINED="contained" | CONTAINMENT="containment";
 
 PredicateDefinition:
-        (kind=PredicateKind "pred"? | "pred")
+        (kind=ErrorKind | kind=PredicateKind? "pred")
         name=Identifier
         "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")"
         ("<->" bodies+=Conjunction (";" bodies+=Conjunction)*)?
         ".";
 
+Conjunction:
+        literals+=Expr ("," literals+=Expr)*;
+
+FunctionDefinition:
+        functionType=[Relation|QualifiedName] name=Identifier
+        "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")"
+        ("=" cases+=Case (";" cases+=Case)*)?
+        ".";
+
+Case:
+        Conjunction ({Match.condition=current} "->" value=Expr)?;
+
 //RuleDefinition:
 //      "rule"
 //      name=Identifier
 //      "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")"
-//      (":" bodies+=Conjunction (";" bodies+=Conjunction)*
+//      (":" preconditions+=Conjunction (";" preconditions+=Conjunction)*)?
 //      "==>" consequents+=Consequent (";" consequents+=Consequent)*)?
 //      ".";
 
 Parameter:
         (modality=Modality? parameterType=[Relation|QualifiedName])? name=Identifier;
 
-Conjunction:
-        literals+=Literal ("," literals+=Literal)*;
-
 //Consequent:
 //      actions+=Action ("," actions+=Action)*;
-
-Literal:
-        Atom | NegativeLiteral | CountLiteral;
-
-NegativeLiteral:
-        modality=Modality? "!" atom=Atom;
-
-enum ComparisonOp:
-        LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | EQ="==" | NOT_EQ="!=";
-
-CountLiteral:
-        modality=Modality? "count" atom=Atom op=ComparisonOp threshold=INT;
-
+//
 //Action:
 //      AssertionAction | DeleteAction | NewAction;
 //
@@ -93,22 +92,74 @@ CountLiteral:
 //NewVariable:
 //      name=Identifier;
 
+Expr:
+        ComparisonExpr;
+
+enum ComparisonOp:
+        LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | EQ="==" | NOT_EQ="!=";
+
+ComparisonExpr returns Expr:
+        AdditiveExpr ({ComparisonExpr.left=current}
+        op=ComparisonOp right=AdditiveExpr)*;
+
+enum AdditiveOp returns BinaryOp:
+        ADD="+" | SUB="-";
+
+AdditiveExpr returns Expr:
+        MultiplicativeExpr ({ArithmeticBinaryExpr.left=current}
+        op=AdditiveOp right=MultiplicativeExpr)*;
+
+enum MultiplicativeOp returns BinaryOp:
+        MUL="*" | DIV="/";
+
+MultiplicativeExpr returns Expr:
+        ExponentialExpr ({ArithmeticBinaryExpr.left=current}
+        op=MultiplicativeOp right=ExponentialExpr)*;
+
+enum ExponentialOp returns BinaryOp:
+        POW="**";
+
+ExponentialExpr returns Expr:
+        UnaryExpr ({ArithmeticBinaryExpr.left=current}
+        op=ExponentialOp right=ExponentialExpr)?;
+
+UnaryExpr returns Expr:
+        ArithmeticUnaryExpr | ModalExpr | NegationExpr | CountExpr | AggregationExpr |
+        Atom | VariableOrNodeExpr | ConstantExpr | "(" Expr ")";
+
+enum UnaryOp:
+        PLUS="+" | MINUS="-";
+
+ArithmeticUnaryExpr:
+        op=UnaryOp body=UnaryExpr;
+
 enum Modality:
         MAY="may" | MUST="must" | CURRENT="current";
 
+ModalExpr:
+        modality=Modality body=UnaryExpr;
+
+NegationExpr:
+        "!" body=UnaryExpr;
+
+CountExpr:
+        "#" body=UnaryExpr;
+
+enum AggregationOp:
+        SUM="sum" | PROD="prod" | MIN="min" | MAX="max";
+
+AggregationExpr:
+        op=AggregationOp "{" value=Expr "|" condition=Expr "}";
+
 Atom:
-        modality=Modality?
         relation=[Relation|QualifiedName]
-        transitiveClosure?="+"?
-        "(" (arguments+=Argument ("," arguments+=Argument)*)? ")";
-
-Argument:
-        VariableOrNodeArgument | ConstantArgument;
+        transitiveClosure?=TRANSITIVE_CLOSURE?
+        "(" (arguments+=Expr ("," arguments+=Expr)*)? ")";
 
-VariableOrNodeArgument:
+VariableOrNodeExpr:
         variableOrNode=[VariableOrNode|QualifiedName];
 
-ConstantArgument:
+ConstantExpr:
         constant=Constant;
 
 Assertion:
@@ -131,7 +182,7 @@ WildcardAssertionArgument:
         {WildcardAssertionArgument} "*";
 
 ConstantAssertionArgument:
-        constant=Constant;
+        negative?="-"? constant=Constant;
 
 enum LogicValue:
         TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error";
@@ -146,7 +197,7 @@ Constant:
         RealConstant | IntConstant | StringConstant;
 
 IntConstant:
-        intValue=Integer;
+        intValue=INT;
 
 RealConstant:
         realValue=Real;
@@ -178,7 +229,7 @@ ExactMultiplicity:
         exactValue=INT;
 
 IndividualDeclaration:
-        "indiv" nodes+=EnumLiteral ("," nodes+=EnumLiteral)* ".";
+        "individual" nodes+=EnumLiteral ("," nodes+=EnumLiteral)* ".";
 
 UpperBound returns ecore::EInt:
         INT | "*";
@@ -190,18 +241,16 @@ QualifiedName hidden():
         Identifier ("::" Identifier)*;
 
 NonRelationKindIdentifier:
-        ID | "true" | "false" | "unknown" | "error" | "class" | "abstract" | "extends" | "enum" |
-        "pred" | "indiv" | "problem" | /* "new" | "delete" | "rule" | */ "may" | "must" | "current" |
-        "count" | "default" | "scope" | "contained" | "containment";
+        ID | "true" | "false" | "contained" | "sum" | "prod" | "min" | "max";
 
 Identifier:
-        NonRelationKindIdentifier | "refers" | "contains" | "container";
-
-Integer returns ecore::EInt hidden():
-        "-"? INT;
+        NonRelationKindIdentifier | "contains";
 
 Real returns ecore::EDouble:
-        "-"? (EXPONENTIAL | INT "." (INT | EXPONENTIAL));
+        EXPONENTIAL | INT "." (INT | EXPONENTIAL);
+
+terminal TRANSITIVE_CLOSURE:
+        "synthetic:TRANSITIVE_CLOSURE";
 
 @Override
 terminal ID:
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 dd7731b4..c0777038 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
@@ -5,6 +5,7 @@ package tools.refinery.language;
 
 import org.eclipse.xtext.conversion.IValueConverterService;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.parser.IParser;
 import org.eclipse.xtext.resource.DerivedStateAwareResource;
 import org.eclipse.xtext.resource.DerivedStateAwareResourceDescriptionManager;
 import org.eclipse.xtext.resource.IDefaultResourceDescriptionStrategy;
@@ -23,6 +24,7 @@ import com.google.inject.name.Names;
 
 import tools.refinery.language.conversion.ProblemValueConverterService;
 import tools.refinery.language.naming.ProblemQualifiedNameConverter;
+import tools.refinery.language.parser.antlr.TokenSourceInjectingProblemParser;
 import tools.refinery.language.resource.ProblemDerivedStateComputer;
 import tools.refinery.language.resource.ProblemLocationInFileProvider;
 import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
@@ -34,6 +36,11 @@ import tools.refinery.language.scoping.ProblemLocalScopeProvider;
  * Equinox extension registry.
  */
 public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
+        @Override
+        public Class<? extends IParser> bindIParser() {
+                return TokenSourceInjectingProblemParser.class;
+        }
+
         public Class<? extends IQualifiedNameConverter> bindIQualifiedNameConverter() {
                 return ProblemQualifiedNameConverter.class;
         }
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 df5d2090..a65e0750 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
@@ -11,17 +11,9 @@ import org.eclipse.xtext.formatting2.regionaccess.ISemanticRegionsFinder;
 import org.eclipse.xtext.formatting2.regionaccess.ISequentialRegion;
 import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
 
-import tools.refinery.language.model.problem.Assertion;
-import tools.refinery.language.model.problem.Atom;
-import tools.refinery.language.model.problem.ClassDeclaration;
-import tools.refinery.language.model.problem.Conjunction;
-import tools.refinery.language.model.problem.IndividualDeclaration;
-import tools.refinery.language.model.problem.NegativeLiteral;
-import tools.refinery.language.model.problem.Parameter;
-import tools.refinery.language.model.problem.PredicateDefinition;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ProblemPackage;
+import tools.refinery.language.model.problem.*;
 
+@SuppressWarnings("UnstableApiUsage")
 public class ProblemFormatter extends AbstractJavaFormatter {
 
         protected void format(Problem problem, IFormattableDocument doc) {
@@ -95,16 +87,14 @@ public class ProblemFormatter extends AbstractJavaFormatter {
                 }
         }
 
-        protected void format(NegativeLiteral literal, IFormattableDocument doc) {
+        protected void format(NegationExpr literal, IFormattableDocument doc) {
                 var region = regionFor(literal);
-                doc.append(region.feature(ProblemPackage.Literals.LITERAL__MODALITY), this::oneSpace);
                 doc.append(region.keyword("!"), this::noSpace);
-                doc.format(literal.getAtom());
+                doc.format(literal.getBody());
         }
 
         protected void format(Atom atom, IFormattableDocument doc) {
                 var region = regionFor(atom);
-                doc.append(region.feature(ProblemPackage.Literals.LITERAL__MODALITY), this::oneSpace);
                 doc.append(region.feature(ProblemPackage.Literals.ATOM__RELATION), this::noSpace);
                 doc.append(region.feature(ProblemPackage.Literals.ATOM__TRANSITIVE_CLOSURE), this::noSpace);
                 formatParenthesizedList(region, doc);
@@ -116,7 +106,7 @@ public class ProblemFormatter extends AbstractJavaFormatter {
         protected void format(IndividualDeclaration individualDeclaration, IFormattableDocument doc) {
                 surroundNewLines(doc, individualDeclaration, this::singleNewLine);
                 var region = regionFor(individualDeclaration);
-                doc.append(region.keyword("indiv"), this::oneSpace);
+                doc.append(region.keyword("individual"), this::oneSpace);
                 formatList(region, ",", doc);
                 doc.prepend(region.keyword("."), this::noSpace);
         }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java
new file mode 100644
index 00000000..ab133a90
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java
@@ -0,0 +1,89 @@
+package tools.refinery.language.parser.antlr;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.antlr.ITokenDefProvider;
+import tools.refinery.language.services.ProblemGrammarAccess;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+@Singleton
+public class IdentifierTokenProvider {
+        private final int[] identifierTokensArray;
+
+        @Inject
+        private IdentifierTokenProvider(Initializer initializer) {
+                this.identifierTokensArray = initializer.getIdentifierTokesArray();
+        }
+
+        public boolean isIdentifierToken(int tokenId) {
+                for (int identifierTokenId : identifierTokensArray) {
+                        if (identifierTokenId == tokenId) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        private static class Initializer {
+                @Inject
+                private ITokenDefProvider tokenDefProvider;
+
+                @Inject
+                private ProblemGrammarAccess problemGrammarAccess;
+
+                private HashMap<String, Integer> valueToTokenIdMap;
+
+                private Set<Integer> identifierTokens;
+
+                public int[] getIdentifierTokesArray() {
+                        createValueToTokenIdMap();
+                        identifierTokens = new HashSet<>();
+                        collectIdentifierTokensFromRule(problemGrammarAccess.getIdentifierRule());
+                        var identifierTokensArray = new int[identifierTokens.size()];
+                        int i = 0;
+                        for (var tokenId : identifierTokens) {
+                                identifierTokensArray[i] = tokenId;
+                                i++;
+                        }
+                        return identifierTokensArray;
+                }
+
+                private void createValueToTokenIdMap() {
+                        var tokenIdToValueMap = tokenDefProvider.getTokenDefMap();
+                        valueToTokenIdMap = new HashMap<>(tokenIdToValueMap.size());
+                        for (var entry : tokenIdToValueMap.entrySet()) {
+                                valueToTokenIdMap.put(entry.getValue(), entry.getKey());
+                        }
+                }
+
+                private void collectIdentifierTokensFromRule(AbstractRule rule) {
+                        if (rule instanceof TerminalRule) {
+                                collectToken("RULE_" + rule.getName());
+                                return;
+                        }
+                        collectIdentifierTokensFromElement(rule.getAlternatives());
+                }
+
+                private void collectIdentifierTokensFromElement(AbstractElement element) {
+                        if (element instanceof Alternatives alternatives) {
+                                for (var alternative : alternatives.getElements()) {
+                                        collectIdentifierTokensFromElement(alternative);
+                                }
+                        } else if (element instanceof RuleCall ruleCall) {
+                                collectIdentifierTokensFromRule(ruleCall.getRule());
+                        } else if (element instanceof Keyword keyword) {
+                                collectToken("'" + keyword.getValue() + "'");
+                        } else {
+                                throw new IllegalArgumentException("Unknown Xtext grammar element: " + element);
+                        }
+                }
+
+                private void collectToken(String value) {
+                        identifierTokens.add(valueToTokenIdMap.get(value));
+                }
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java
new file mode 100644
index 00000000..0b4e7185
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java
@@ -0,0 +1,125 @@
+/*
+ * generated by Xtext 2.29.0.M2
+ */
+package tools.refinery.language.parser.antlr;
+
+import com.google.inject.Inject;
+import org.antlr.runtime.Token;
+import org.antlr.runtime.TokenSource;
+import tools.refinery.language.parser.antlr.internal.InternalProblemParser;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class ProblemTokenSource implements TokenSource {
+        private IdentifierTokenProvider identifierTokenProvider;
+
+        private final TokenSource delegate;
+
+        private final Deque<Token> buffer = new ArrayDeque<>();
+
+        private boolean recursive;
+
+        private boolean seenId;
+
+        public ProblemTokenSource(TokenSource delegate) {
+                this.delegate = delegate;
+        }
+
+        @Inject
+        public void setIdentifierTokenProvider(IdentifierTokenProvider identifierTokenProvider) {
+                this.identifierTokenProvider = identifierTokenProvider;
+        }
+
+        public boolean isRecursive() {
+                return recursive;
+        }
+
+        public void setRecursive(boolean recursive) {
+                this.recursive = recursive;
+        }
+
+        @Override
+        public Token nextToken() {
+                if (!buffer.isEmpty()) {
+                        return buffer.removeFirst();
+                }
+                var token = delegate.nextToken();
+                if (isIdentifier(token)) {
+                        seenId = true;
+                } else if (seenId && isPlusOrTransitiveClosure(token)) {
+                        if (peekForTransitiveClosure()) {
+                                token.setType(InternalProblemParser.RULE_TRANSITIVE_CLOSURE);
+                        }
+                } else if (isVisibleToken(token)) {
+                        seenId = false;
+                }
+                return token;
+        }
+
+        @Override
+        public String getSourceName() {
+                return "[%s]%s".formatted(this.getClass().getSimpleName(), delegate.getSourceName());
+        }
+
+        protected boolean isIdentifier(Token token) {
+                return identifierTokenProvider.isIdentifierToken(token.getType());
+        }
+
+        protected boolean isPlusOrTransitiveClosure(Token token) {
+                return token.getType() == InternalProblemParser.PlusSign;
+        }
+
+        protected boolean isVisibleToken(Token token) {
+                int tokenId = token.getType();
+                return tokenId != InternalProblemParser.RULE_WS && tokenId != InternalProblemParser.RULE_SL_COMMENT &&
+                                tokenId != InternalProblemParser.RULE_ML_COMMENT;
+        }
+
+        protected boolean peekForTransitiveClosure() {
+                Token token = peekWithSkipWhitespace();
+                if (token.getType() != InternalProblemParser.LeftParenthesis) {
+                        return false;
+                }
+                while (true) {
+                        token = peekWithSkipWhitespace();
+                        if (!isIdentifier(token)) {
+                                return false;
+                        }
+                        token = peekWithSkipWhitespace();
+                        switch (token.getType()) {
+                        case InternalProblemParser.Comma:
+                                return true;
+                        case InternalProblemParser.ColonColon:
+                                break;
+                        default:
+                                // By default, we do not peek at inner plus signs to limit recursion depth.
+                                // Such expressions are never valid, so we don't have to parse them correctly.
+                                if (recursive && isPlusOrTransitiveClosure(token) && peekForTransitiveClosure()) {
+                                        token.setType(InternalProblemParser.RULE_TRANSITIVE_CLOSURE);
+                                }
+                                // Not a transitive closure for the initial position where we started peeking.
+                                return false;
+                        }
+                }
+        }
+
+        protected Token peekToken() {
+                var token = delegate.nextToken();
+                if (isIdentifier(token)) {
+                        seenId = true;
+                } else if (isVisibleToken(token)) {
+                        seenId = false;
+                }
+                buffer.addLast(token);
+                return token;
+        }
+
+        protected Token peekWithSkipWhitespace() {
+                Token token;
+                do {
+                        token = peekToken();
+                } while (token != null && !isVisibleToken(token));
+                return token;
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/TokenSourceInjectingProblemParser.java b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/TokenSourceInjectingProblemParser.java
new file mode 100644
index 00000000..0cdd38d8
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/TokenSourceInjectingProblemParser.java
@@ -0,0 +1,18 @@
+package tools.refinery.language.parser.antlr;
+
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import org.antlr.runtime.CharStream;
+import org.antlr.runtime.TokenSource;
+
+public class TokenSourceInjectingProblemParser extends ProblemParser {
+        @Inject
+        private Injector injector;
+
+        @Override
+        protected TokenSource createLexer(CharStream stream) {
+                var tokenSource = super.createLexer(stream);
+                injector.injectMembers(tokenSource);
+                return tokenSource;
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/DerivedVariableComputer.java b/subprojects/language/src/main/java/tools/refinery/language/resource/DerivedVariableComputer.java
index b76c4bf7..6176b0c4 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/DerivedVariableComputer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/DerivedVariableComputer.java
@@ -1,36 +1,15 @@
 package tools.refinery.language.resource;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import com.google.inject.name.Named;
 import org.eclipse.xtext.linking.impl.LinkingHelper;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
-import org.eclipse.xtext.nodemodel.INode;
-import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
-import org.eclipse.xtext.scoping.IScope;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+import tools.refinery.language.model.problem.*;
 
-import com.google.inject.Inject;
-import com.google.inject.Singleton;
-import com.google.inject.name.Named;
-
-import tools.refinery.language.model.problem.Argument;
-import tools.refinery.language.model.problem.Atom;
-import tools.refinery.language.model.problem.CompoundLiteral;
-import tools.refinery.language.model.problem.Conjunction;
-import tools.refinery.language.model.problem.ExistentialQuantifier;
-import tools.refinery.language.model.problem.ImplicitVariable;
-import tools.refinery.language.model.problem.Literal;
-import tools.refinery.language.model.problem.Parameter;
-import tools.refinery.language.model.problem.ParametricDefinition;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ProblemFactory;
-import tools.refinery.language.model.problem.ProblemPackage;
-import tools.refinery.language.model.problem.Statement;
-import tools.refinery.language.model.problem.VariableOrNodeArgument;
-import tools.refinery.language.naming.NamingUtil;
+import java.util.*;
 
 @Singleton
 public class DerivedVariableComputer {
@@ -53,107 +32,60 @@ public class DerivedVariableComputer {
         }
 
         protected void installDerivedParametricDefinitionState(ParametricDefinition definition, Set<String> nodeNames) {
-                Set<String> knownVariables = new HashSet<>();
-                knownVariables.addAll(nodeNames);
+                Set<String> knownVariables = new HashSet<>(nodeNames);
                 for (Parameter parameter : definition.getParameters()) {
                         String name = parameter.getName();
                         if (name != null) {
                                 knownVariables.add(name);
                         }
                 }
-                for (Conjunction body : definition.getBodies()) {
-                        installDeriveConjunctionState(body, knownVariables);
+                if (definition instanceof PredicateDefinition predicateDefinition) {
+                        installDerivedPredicateDefinitionState(predicateDefinition, knownVariables);
+                } else if (definition instanceof FunctionDefinition functionDefinition) {
+                        installDerivedFunctionDefinitionState(functionDefinition, knownVariables);
+                } else if (definition instanceof RuleDefinition ruleDefinition) {
+                        installDerivedRuleDefinitionState(ruleDefinition, knownVariables);
+                } else {
+                        throw new IllegalArgumentException("Unknown ParametricDefinition: " + definition);
                 }
         }
 
-        protected void installDeriveConjunctionState(Conjunction conjunction, Set<String> knownVariables) {
-                Set<String> newVariables = new HashSet<>();
-                for (Literal literal : conjunction.getLiterals()) {
-                        if (literal instanceof Atom atom) {
-                                createSigletonVariablesAndCollectVariables(atom, knownVariables, newVariables);
-                        }
-                }
-                createVariables(conjunction, newVariables);
-                newVariables.addAll(knownVariables);
-                for (Literal literal : conjunction.getLiterals()) {
-                        if (literal instanceof CompoundLiteral compoundLiteral) {
-                                installDerivedCompoundLiteralState(compoundLiteral, newVariables);
-                        }
+        protected void installDerivedPredicateDefinitionState(PredicateDefinition definition, Set<String> knownVariables) {
+                for (Conjunction body : definition.getBodies()) {
+                        createVariablesForScope(new ImplicitVariableScope(body, knownVariables));
                 }
         }
 
-        protected void installDerivedCompoundLiteralState(CompoundLiteral compoundLiteral, Set<String> knownVariables) {
-                Set<String> newVariables = new HashSet<>();
-                createSigletonVariablesAndCollectVariables(compoundLiteral.getAtom(), knownVariables, newVariables);
-                createVariables(compoundLiteral, newVariables);
-        }
-
-        protected void createSigletonVariablesAndCollectVariables(Atom atom, Set<String> knownVariables,
-                        Set<String> newVariables) {
-                for (Argument argument : atom.getArguments()) {
-                        if (argument instanceof VariableOrNodeArgument variableOrNodeArgument) {
-                                IScope scope = scopeProvider.getScope(variableOrNodeArgument,
-                                                ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE);
-                                List<INode> nodes = NodeModelUtils.findNodesForFeature(variableOrNodeArgument,
-                                                ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE);
-                                for (INode node : nodes) {
-                                        var variableName = linkingHelper.getCrossRefNodeAsString(node, true);
-                                        var created = tryCreateVariableForArgument(variableOrNodeArgument, variableName, scope,
-                                                        knownVariables, newVariables);
-                                        if (created) {
-                                                break;
-                                        }
+        protected void installDerivedFunctionDefinitionState(FunctionDefinition definition, Set<String> knownVariables) {
+                for (Case body : definition.getCases()) {
+                        if (body instanceof Conjunction conjunction) {
+                                createVariablesForScope(new ImplicitVariableScope(conjunction, knownVariables));
+                        } else if (body instanceof Match match) {
+                                var condition = match.getCondition();
+                                if (condition != null) {
+                                        createVariablesForScope(new ImplicitVariableScope(match, match.getCondition(), knownVariables));
                                 }
+                        } else {
+                                throw new IllegalArgumentException("Unknown Case: " + body);
                         }
                 }
         }
 
-        protected boolean tryCreateVariableForArgument(VariableOrNodeArgument variableOrNodeArgument, String variableName,
-                        IScope scope, Set<String> knownVariables, Set<String> newVariables) {
-                if (!NamingUtil.isValidId(variableName)) {
-                        return false;
-                }
-                var qualifiedName = qualifiedNameConverter.toQualifiedName(variableName);
-                if (scope.getSingleElement(qualifiedName) != null) {
-                        return false;
-                }
-                if (NamingUtil.isSingletonVariableName(variableName)) {
-                        createSingletonVariable(variableOrNodeArgument, variableName);
-                        return true;
-                }
-                if (!knownVariables.contains(variableName)) {
-                        newVariables.add(variableName);
-                        return true;
-                }
-                return false;
-        }
-
-        protected void createVariables(ExistentialQuantifier quantifier, Set<String> newVariables) {
-                for (String variableName : newVariables) {
-                        createVariable(quantifier, variableName);
-                }
-        }
-
-        protected void createVariable(ExistentialQuantifier quantifier, String variableName) {
-                if (NamingUtil.isValidId(variableName)) {
-                        ImplicitVariable variable = createNamedVariable(variableName);
-                        quantifier.getImplicitVariables().add(variable);
+        protected void installDerivedRuleDefinitionState(RuleDefinition definition, Set<String> knownVariables) {
+                for (Conjunction precondition : definition.getPreconditions()) {
+                        createVariablesForScope(new ImplicitVariableScope(precondition, knownVariables));
                 }
         }
 
-        protected void createSingletonVariable(VariableOrNodeArgument argument, String variableName) {
-                if (NamingUtil.isValidId(variableName)) {
-                        ImplicitVariable variable = createNamedVariable(variableName);
-                        argument.setSingletonVariable(variable);
+        protected void createVariablesForScope(ImplicitVariableScope scope) {
+                var queue = new ArrayDeque<ImplicitVariableScope>();
+                queue.addLast(scope);
+                while (!queue.isEmpty()) {
+                        var nextScope = queue.removeFirst();
+                        nextScope.createVariables(scopeProvider, linkingHelper, qualifiedNameConverter, queue);
                 }
         }
 
-        protected ImplicitVariable createNamedVariable(String variableName) {
-                var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
-                variable.setName(variableName);
-                return variable;
-        }
-
         public void discardDerivedVariables(Problem problem) {
                 for (Statement statement : problem.getStatements()) {
                         if (statement instanceof ParametricDefinition parametricDefinition) {
@@ -163,28 +95,31 @@ public class DerivedVariableComputer {
         }
 
         protected void discardParametricDefinitionState(ParametricDefinition definition) {
-                for (Conjunction body : definition.getBodies()) {
-                        body.getImplicitVariables().clear();
-                        for (Literal literal : body.getLiterals()) {
-                                if (literal instanceof Atom atom) {
-                                        discardDerivedAtomState(atom);
-                                }
-                                if (literal instanceof CompoundLiteral compoundLiteral) {
-                                        compoundLiteral.getImplicitVariables().clear();
-                                        discardDerivedAtomState(compoundLiteral.getAtom());
-                                }
+                List<ExistentialQuantifier> existentialQuantifiers = new ArrayList<>();
+                List<VariableOrNodeExpr> variableOrNodeExprs = new ArrayList<>();
+                var treeIterator = definition.eAllContents();
+                // We must collect the nodes where we are discarding derived state and only discard them after the iteration,
+                // because modifying the containment hierarchy during iteration causes the TreeIterator to fail with
+                // IndexOutOfBoundsException.
+                while (treeIterator.hasNext()) {
+                        var child = treeIterator.next();
+                        var containingFeature = child.eContainingFeature();
+                        if (containingFeature == ProblemPackage.Literals.EXISTENTIAL_QUANTIFIER__IMPLICIT_VARIABLES ||
+                                        containingFeature == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__SINGLETON_VARIABLE) {
+                                treeIterator.prune();
+                        } else if (child instanceof ExistentialQuantifier existentialQuantifier &&
+                                        !existentialQuantifier.getImplicitVariables().isEmpty()) {
+                                existentialQuantifiers.add(existentialQuantifier);
+                        } else if (child instanceof VariableOrNodeExpr variableOrNodeExpr &&
+                                        variableOrNodeExpr.getSingletonVariable() != null) {
+                                variableOrNodeExprs.add(variableOrNodeExpr);
                         }
                 }
-        }
-
-        protected void discardDerivedAtomState(Atom atom) {
-                if (atom == null) {
-                        return;
+                for (var existentialQuantifier : existentialQuantifiers) {
+                        existentialQuantifier.getImplicitVariables().clear();
                 }
-                for (Argument argument : atom.getArguments()) {
-                        if (argument instanceof VariableOrNodeArgument variableOrNodeArgument) {
-                                variableOrNodeArgument.setSingletonVariable(null);
-                        }
+                for (var variableOrNodeExpr : variableOrNodeExprs) {
+                        variableOrNodeExpr.setSingletonVariable(null);
                 }
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ImplicitVariableScope.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ImplicitVariableScope.java
new file mode 100644
index 00000000..b0ac2ab6
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ImplicitVariableScope.java
@@ -0,0 +1,138 @@
+package tools.refinery.language.resource;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.linking.impl.LinkingHelper;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import tools.refinery.language.model.problem.*;
+import tools.refinery.language.naming.NamingUtil;
+
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ImplicitVariableScope {
+        private final EObject root;
+
+        private final ExistentialQuantifier quantifier;
+
+        private final ImplicitVariableScope parent;
+
+        private Set<String> knownVariables;
+
+        private ImplicitVariableScope(ExistentialQuantifier quantifier, ImplicitVariableScope parent) {
+                this.root = quantifier;
+                this.quantifier = quantifier;
+                this.parent = parent;
+                this.knownVariables = null;
+        }
+
+        public ImplicitVariableScope(EObject root, ExistentialQuantifier quantifier, Set<String> knownVariables) {
+                this.root = root;
+                this.quantifier = quantifier;
+                this.parent = null;
+                this.knownVariables = new HashSet<>(knownVariables);
+        }
+
+        public ImplicitVariableScope(ExistentialQuantifier root, Set<String> knownVariables) {
+                this(root, root, knownVariables);
+        }
+
+        public void createVariables(IScopeProvider scopeProvider, LinkingHelper linkingHelper,
+                                                                IQualifiedNameConverter qualifiedNameConverter,
+                                                                Deque<ImplicitVariableScope> scopeQueue) {
+                initializeKnownVariables();
+                processEObject(root, scopeProvider, linkingHelper, qualifiedNameConverter);
+                var treeIterator = root.eAllContents();
+                while (treeIterator.hasNext()) {
+                        var child = treeIterator.next();
+                        if (child instanceof ExistentialQuantifier nestedQuantifier) {
+                                scopeQueue.addLast(new ImplicitVariableScope(nestedQuantifier, this));
+                                treeIterator.prune();
+                        } else {
+                                processEObject(child, scopeProvider, linkingHelper, qualifiedNameConverter);
+                        }
+                }
+        }
+
+        private void initializeKnownVariables() {
+                boolean hasKnownVariables = knownVariables != null;
+                boolean hasParent = parent != null;
+                if ((hasKnownVariables && hasParent) || (!hasKnownVariables && !hasParent)) {
+                        throw new IllegalStateException("Either known variables or parent must be provided, but not both");
+                }
+                if (hasKnownVariables) {
+                        return;
+                }
+                if (parent.knownVariables == null) {
+                        throw new IllegalStateException("Parent scope must be processed before current scope");
+                }
+                knownVariables = new HashSet<>(parent.knownVariables);
+        }
+
+        private void processEObject(EObject eObject, IScopeProvider scopeProvider, LinkingHelper linkingHelper,
+                                                                IQualifiedNameConverter qualifiedNameConverter) {
+                if (!(eObject instanceof VariableOrNodeExpr variableOrNodeExpr)) {
+                        return;
+                }
+                IScope scope = scopeProvider.getScope(variableOrNodeExpr,
+                                ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE);
+                List<INode> nodes = NodeModelUtils.findNodesForFeature(variableOrNodeExpr,
+                                ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE);
+                for (INode node : nodes) {
+                        var variableName = linkingHelper.getCrossRefNodeAsString(node, true);
+                        var created = tryCreateVariableForArgument(variableOrNodeExpr, variableName, qualifiedNameConverter,
+                                        scope);
+                        if (created) {
+                                break;
+                        }
+                }
+        }
+
+        protected boolean tryCreateVariableForArgument(VariableOrNodeExpr variableOrNodeExpr, String variableName,
+                                                                                                   IQualifiedNameConverter qualifiedNameConverter, IScope scope) {
+                if (!NamingUtil.isValidId(variableName)) {
+                        return false;
+                }
+                QualifiedName qualifiedName;
+                try {
+                        qualifiedName = qualifiedNameConverter.toQualifiedName(variableName);
+                } catch (IllegalArgumentException e) {
+                        return false;
+                }
+                if (scope.getSingleElement(qualifiedName) != null) {
+                        return false;
+                }
+                if (NamingUtil.isSingletonVariableName(variableName)) {
+                        createSingletonVariable(variableOrNodeExpr, variableName);
+                        return true;
+                }
+                if (!knownVariables.contains(variableName)) {
+                        createVariable(variableName);
+                        return true;
+                }
+                return false;
+        }
+
+        protected void createVariable(String variableName) {
+                knownVariables.add(variableName);
+                ImplicitVariable variable = createNamedVariable(variableName);
+                quantifier.getImplicitVariables().add(variable);
+        }
+
+        protected void createSingletonVariable(VariableOrNodeExpr variableOrNodeExpr, String variableName) {
+                ImplicitVariable variable = createNamedVariable(variableName);
+                variableOrNodeExpr.setSingletonVariable(variable);
+        }
+
+        protected ImplicitVariable createNamedVariable(String variableName) {
+                var variable = ProblemFactory.eINSTANCE.createImplicitVariable();
+                variable.setName(variableName);
+                return variable;
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemXmiResourceFactory.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemXmiResourceFactory.java
deleted file mode 100644
index 68aa6016..00000000
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemXmiResourceFactory.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package tools.refinery.language.resource;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.xtext.resource.IResourceFactory;
-
-import tools.refinery.language.model.problem.util.ProblemResourceFactoryImpl;
-
-public class ProblemXmiResourceFactory implements IResourceFactory {
-        private Resource.Factory problemResourceFactory = new ProblemResourceFactoryImpl();
-        
-        @Override
-        public Resource createResource(URI uri) {
-                return problemResourceFactory.createResource(uri);
-        }
-}
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 567c3c26..c2045aea 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
@@ -3,34 +3,23 @@
  */
 package tools.refinery.language.scoping;
 
-import java.util.ArrayList;
-import java.util.List;
-
+import com.google.inject.Inject;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.xtext.EcoreUtil2;
 import org.eclipse.xtext.scoping.IScope;
 import org.eclipse.xtext.scoping.Scopes;
-
-import com.google.inject.Inject;
-
-import tools.refinery.language.model.problem.ClassDeclaration;
-import tools.refinery.language.model.problem.Consequent;
-import tools.refinery.language.model.problem.ExistentialQuantifier;
-import tools.refinery.language.model.problem.NewAction;
-import tools.refinery.language.model.problem.ParametricDefinition;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ProblemPackage;
-import tools.refinery.language.model.problem.ReferenceDeclaration;
-import tools.refinery.language.model.problem.Variable;
-import tools.refinery.language.model.problem.VariableOrNodeArgument;
+import tools.refinery.language.model.problem.*;
 import tools.refinery.language.utils.ProblemDesugarer;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * This class contains custom scoping description.
- *
+ * <p>
  * See
- * https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping
+ * <a href="https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping">...</a>
  * on how and when to use it.
  */
 public class ProblemScopeProvider extends AbstractProblemScopeProvider {
@@ -44,7 +33,7 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
                                 || reference == ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE) {
                         return getNodesScope(context, scope);
                 }
-                if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE
+                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) {
                         return getVariableScope(context, scope);
@@ -80,8 +69,8 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
         }
 
         protected void addSingletonVariableToScope(EObject context, List<Variable> variables) {
-                if (context instanceof VariableOrNodeArgument argument) {
-                        Variable singletonVariable = argument.getSingletonVariable();
+                if (context instanceof VariableOrNodeExpr expr) {
+                        Variable singletonVariable = expr.getSingletonVariable();
                         if (singletonVariable != null) {
                                 variables.add(singletonVariable);
                         }
@@ -91,6 +80,8 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
         protected void addExistentiallyQualifiedVariableToScope(EObject currentContext, List<Variable> variables) {
                 if (currentContext instanceof ExistentialQuantifier quantifier) {
                         variables.addAll(quantifier.getImplicitVariables());
+                } else if (currentContext instanceof Match match) {
+                        variables.addAll(match.getCondition().getImplicitVariables());
                 } else if (currentContext instanceof Consequent consequent) {
                         for (var literal : consequent.getActions()) {
                                 if (literal instanceof NewAction newAction && newAction.getVariable() != null) {
@@ -106,10 +97,9 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
                         return delegateScope;
                 }
                 var relation = referenceDeclaration.getReferenceType();
-                if (!(relation instanceof ClassDeclaration)) {
+                if (!(relation instanceof ClassDeclaration classDeclaration)) {
                         return delegateScope;
                 }
-                var classDeclaration = (ClassDeclaration) relation;
                 var referenceDeclarations = desugarer.getAllReferenceDeclarations(classDeclaration);
                 return Scopes.scopeFor(referenceDeclarations, delegateScope);
         }
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 a7acd747..1e5164d3 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
@@ -44,7 +44,7 @@ public final class ProblemUtil {
         }
 
         public static boolean isSingletonVariable(Variable variable) {
-                return variable.eContainingFeature() == ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__SINGLETON_VARIABLE;
+                return variable.eContainingFeature() == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__SINGLETON_VARIABLE;
         }
 
         public static boolean isImplicitVariable(Variable variable) {
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 a0e78e1d..659d882c 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
@@ -8,19 +8,15 @@ import org.eclipse.xtext.validation.Check;
 
 import com.google.inject.Inject;
 
-import tools.refinery.language.model.problem.Node;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ProblemPackage;
-import tools.refinery.language.model.problem.Variable;
-import tools.refinery.language.model.problem.VariableOrNodeArgument;
+import tools.refinery.language.model.problem.*;
 import tools.refinery.language.resource.ReferenceCounter;
 import tools.refinery.language.utils.ProblemUtil;
 
 /**
  * This class contains custom validation rules.
- *
+ * <p>
  * See
- * https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ * <a href="https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation">...</a>
  */
 public class ProblemValidator extends AbstractProblemValidator {
         private static final String ISSUE_PREFIX = "tools.refinery.language.validation.ProblemValidator.";
@@ -33,29 +29,29 @@ public class ProblemValidator extends AbstractProblemValidator {
         private ReferenceCounter referenceCounter;
 
         @Check
-        public void checkUniqueVariable(VariableOrNodeArgument argument) {
-                var variableOrNode = argument.getVariableOrNode();
+        public void checkUniqueVariable(VariableOrNodeExpr expr) {
+                var variableOrNode = expr.getVariableOrNode();
                 if (variableOrNode instanceof Variable variable && ProblemUtil.isImplicitVariable(variable)
                                 && !ProblemUtil.isSingletonVariable(variable)) {
                         var problem = EcoreUtil2.getContainerOfType(variable, Problem.class);
                         if (problem != null && referenceCounter.countReferences(problem, variable) <= 1) {
                                 var name = variable.getName();
-                                var message = "Variable '%s' has only a single reference. Add another reference or mark is as a singleton variable: '_%s'"
-                                                .formatted(name, name);
-                                warning(message, argument, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE,
+                                var message = ("Variable '%s' has only a single reference. " +
+                                                "Add another reference or mark is as a singleton variable: '_%s'").formatted(name, name);
+                                warning(message, expr, ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE,
                                                 INSIGNIFICANT_INDEX, SINGLETON_VARIABLE_ISSUE);
                         }
                 }
         }
 
         @Check
-        public void checkNonUniqueNode(VariableOrNodeArgument argument) {
-                var variableOrNode = argument.getVariableOrNode();
+        public void checkNonUniqueNode(VariableOrNodeExpr expr) {
+                var variableOrNode = expr.getVariableOrNode();
                 if (variableOrNode instanceof Node node && !ProblemUtil.isIndividualNode(node)) {
                         var name = node.getName();
-                        var message = "Only individual nodes can be referenced in predicates. Mark '%s' as individual with the declaration 'indiv %s.'"
-                                        .formatted(name, name);
-                        error(message, argument, ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__VARIABLE_OR_NODE,
+                        var message = ("Only individual nodes can be referenced in predicates. " +
+                                        "Mark '%s' as individual with the declaration 'indiv %s.'").formatted(name, name);
+                        error(message, expr, ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE,
                                         INSIGNIFICANT_INDEX, NON_INDIVIDUAL_NODE_ISSUE);
                 }
         }