refactor: separate primitive types from nodes

11 files changed, 237 insertions, 284 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 bc1ee465..8b13a693 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -10,14 +10,13 @@ Problem:
 Statement:
         ClassDeclaration | EnumDeclaration |
         PredicateDefinition | FunctionDefinition | /* RuleDefinition | */
-        Assertion | NodeValueAssertion |
-        ScopeDeclaration | IndividualDeclaration;
+        Assertion | ScopeDeclaration | IndividualDeclaration;
 
 ClassDeclaration:
         abstract?="abstract"? "class"
         name=Identifier
         ("extends" superTypes+=[Relation|QualifiedName] ("," superTypes+=[Relation|QualifiedName])*)?
-        ("{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" | ".");
+        ("{" (featureDeclarations+=FeatureDeclaration ";"?)* "}" | ".");
 
 EnumDeclaration:
         "enum"
@@ -27,16 +26,27 @@ EnumDeclaration:
 EnumLiteral returns Node:
         name=Identifier;
 
+FeatureDeclaration:
+        ReferenceDeclaration | AttributeDeclaration | FlagDeclaration;
+
 enum ReferenceKind:
         REFERENCE="refers" | CONTAINMENT="contains" | CONTAINER="container";
 
 ReferenceDeclaration:
-        (kind=ReferenceKind referenceType=[Relation|QualifiedName] |
-        referenceType=[Relation|NonRelationKindQualifiedName])
+        kind=ReferenceKind referenceType=[Relation|QualifiedName]
         ("[" multiplicity=Multiplicity "]")?
         name=Identifier
         ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?;
 
+enum PrimitiveType:
+        INT="int" | REAL="real" | STRING="string";
+
+AttributeDeclaration:
+        attributeType=PrimitiveType name=Identifier;
+
+FlagDeclaration:
+        "bool" name=Identifier;
+
 enum ErrorKind returns PredicateKind:
         ERROR="error";
 
@@ -54,7 +64,7 @@ Conjunction:
         literals+=Expr ("," literals+=Expr)*;
 
 FunctionDefinition:
-        functionType=[Relation|QualifiedName] name=Identifier
+        functionType=PrimitiveType name=Identifier
         "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")"
         ("=" cases+=Case (";" cases+=Case)*)?
         ".";
@@ -96,11 +106,21 @@ Expr:
         ComparisonExpr;
 
 enum ComparisonOp:
-        LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | EQ="==" | NOT_EQ="!=";
+        LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | EQ="==" | NOT_EQ="!=" | IN="in";
 
 ComparisonExpr returns Expr:
-        AdditiveExpr ({ComparisonExpr.left=current}
-        op=ComparisonOp right=AdditiveExpr)*;
+        LatticeExpr ({ComparisonExpr.left=current}
+        op=ComparisonOp right=LatticeExpr)*;
+
+enum LatticeOp returns BinaryOp:
+        MEET="/\\" | JOIN="\\/";
+
+LatticeExpr returns Expr:
+        RangeExpr ({ArithmeticBinaryExpr.left=current}
+        op=LatticeOp right=RangeExpr)*;
+
+RangeExpr returns Expr:
+        AdditiveExpr ({RangeExpr.left=current} ".." right=AdditiveExpr)*;
 
 enum AdditiveOp returns BinaryOp:
         ADD="+" | SUB="-";
@@ -125,7 +145,7 @@ ExponentialExpr returns Expr:
 
 UnaryExpr returns Expr:
         ArithmeticUnaryExpr | ModalExpr | NegationExpr | CountExpr | AggregationExpr |
-        Atom | VariableOrNodeExpr | ConstantExpr | "(" Expr ")";
+        Atom | VariableOrNodeExpr | Constant | "(" Expr ")";
 
 enum UnaryOp:
         PLUS="+" | MINUS="-";
@@ -159,21 +179,33 @@ Atom:
 VariableOrNodeExpr:
         variableOrNode=[VariableOrNode|QualifiedName];
 
-ConstantExpr:
-        constant=Constant;
+Constant:
+        RealConstant | IntConstant | InfConstant | StringConstant;
+
+IntConstant:
+        intValue=INT;
+
+RealConstant:
+        realValue=Real;
+
+InfConstant:
+        {InfConstant} "*";
+
+StringConstant:
+        stringValue=STRING;
 
 Assertion:
         default?="default"?
-        (value=ShortLogicValue?
-        relation=[Relation|QualifiedName]
-        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")"
-        | relation=[Relation|QualifiedName]
+        (relation=[Relation|QualifiedName]
         "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")"
-        ":" value=LogicValue)
+        value=AssertionValue |
+        value=ShortLogicAssertionValue
+        relation=[Relation|QualifiedName]
+        "(" (arguments+=AssertionArgument ("," arguments+=AssertionArgument)*)? ")")
         ".";
 
 AssertionArgument:
-        NodeAssertionArgument | WildcardAssertionArgument | ConstantAssertionArgument;
+        NodeAssertionArgument | WildcardAssertionArgument;
 
 NodeAssertionArgument:
         node=[Node|QualifiedName];
@@ -181,29 +213,23 @@ NodeAssertionArgument:
 WildcardAssertionArgument:
         {WildcardAssertionArgument} "*";
 
-ConstantAssertionArgument:
-        negative?="-"? constant=Constant;
+AssertionValue:
+        LogicAssertionValue | ExprAssertionValue;
 
 enum LogicValue:
         TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error";
 
-enum ShortLogicValue returns LogicValue:
-        FALSE="!" | UNKNOWN="?";
+LogicAssertionValue:
+        ":" logicValue=LogicValue;
 
-NodeValueAssertion:
-        node=[Node|QualifiedName] ":" value=Constant ".";
-
-Constant:
-        RealConstant | IntConstant | StringConstant;
-
-IntConstant:
-        intValue=INT;
+ExprAssertionValue:
+        (range?="in" | "=") body=Expr;
 
-RealConstant:
-        realValue=Real;
+enum ShortLogicValue returns LogicValue:
+        FALSE="!" | UNKNOWN="?";
 
-StringConstant:
-        stringValue=STRING;
+ShortLogicAssertionValue returns LogicAssertionValue:
+        {LogicAssertionValue} logicValue=ShortLogicValue?;
 
 ScopeDeclaration:
         "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* ".";
@@ -234,17 +260,11 @@ IndividualDeclaration:
 UpperBound returns ecore::EInt:
         INT | "*";
 
-NonRelationKindQualifiedName hidden():
-        NonRelationKindIdentifier ("::" Identifier)*;
-
 QualifiedName hidden():
         Identifier ("::" Identifier)*;
 
-NonRelationKindIdentifier:
-        ID | "true" | "false" | "contained" | "sum" | "prod" | "min" | "max";
-
 Identifier:
-        NonRelationKindIdentifier | "contains";
+        ID | "contains" | "contained" | "sum" | "prod" | "min" | "max";
 
 Real returns ecore::EDouble:
         EXPONENTIAL | INT "." (INT | EXPONENTIAL);
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 c0777038..5efcdc81 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
@@ -3,25 +3,18 @@
  */
 package tools.refinery.language;
 
+import com.google.inject.Binder;
+import com.google.inject.name.Names;
 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;
-import org.eclipse.xtext.resource.IDerivedStateComputer;
-import org.eclipse.xtext.resource.ILocationInFileProvider;
-import org.eclipse.xtext.resource.IResourceDescription;
-import org.eclipse.xtext.resource.XtextResource;
+import org.eclipse.xtext.resource.*;
 import org.eclipse.xtext.scoping.IGlobalScopeProvider;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
 import org.eclipse.xtext.validation.IResourceValidator;
 import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
-
-import com.google.inject.Binder;
-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;
@@ -30,6 +23,7 @@ import tools.refinery.language.resource.ProblemLocationInFileProvider;
 import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
 import tools.refinery.language.scoping.ProblemGlobalScopeProvider;
 import tools.refinery.language.scoping.ProblemLocalScopeProvider;
+import tools.refinery.language.serializer.PreferShortAssertionsProblemSemanticSequencer;
 
 /**
  * Use this class to register components to be used at runtime / without the
@@ -88,4 +82,9 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         public Class<? extends ILocationInFileProvider> bindILocationInFileProvider() {
                 return ProblemLocationInFileProvider.class;
         }
+
+        @Override
+        public Class<? extends ISemanticSequencer> bindISemanticSequencer() {
+                return PreferShortAssertionsProblemSemanticSequencer.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 a65e0750..46870edb 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
@@ -3,6 +3,7 @@
  */
 package tools.refinery.language.formatting2;
 
+import com.google.inject.Inject;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.formatting2.AbstractJavaFormatter;
 import org.eclipse.xtext.formatting2.IFormattableDocument;
@@ -12,9 +13,12 @@ import org.eclipse.xtext.formatting2.regionaccess.ISequentialRegion;
 import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
 
 import tools.refinery.language.model.problem.*;
+import tools.refinery.language.services.ProblemGrammarAccess;
 
 @SuppressWarnings("UnstableApiUsage")
 public class ProblemFormatter extends AbstractJavaFormatter {
+        @Inject
+        private ProblemGrammarAccess problemGrammarAccess;
 
         protected void format(Problem problem, IFormattableDocument doc) {
                 doc.prepend(problem, this::noSpace);
@@ -31,17 +35,35 @@ 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__VALUE), this::noSpace);
                 doc.append(region.feature(ProblemPackage.Literals.ASSERTION__RELATION), this::noSpace);
                 formatParenthesizedList(region, doc);
-                doc.prepend(region.keyword(":"), this::noSpace);
-                doc.append(region.keyword(":"), this::oneSpace);
+                var value = assertion.getValue();
+                if (value != null) {
+                        doc.append(value, this::noSpace);
+                        doc.format(value);
+                }
                 doc.prepend(region.keyword("."), this::noSpace);
                 for (var argument : assertion.getArguments()) {
                         doc.format(argument);
                 }
         }
 
+        protected void format(LogicAssertionValue assertionValue, IFormattableDocument doc) {
+                var region = regionFor(assertionValue);
+                doc.prepend(region.keyword(":"), this::noSpace);
+                doc.append(region.keyword(":"), this::oneSpace);
+        }
+
+        protected void format(ExprAssertionValue assertionValue, IFormattableDocument doc) {
+                var region = regionFor(assertionValue);
+                doc.surround(region.keyword("="), this::oneSpace);
+                doc.surround(region.keyword("in"), this::oneSpace);
+                var body = assertionValue.getBody();
+                if (body != null) {
+                        doc.format(body);
+                }
+        }
+
         protected void format(ClassDeclaration classDeclaration, IFormattableDocument doc) {
                 surroundNewLines(doc, classDeclaration, this::twoNewLines);
                 var region = regionFor(classDeclaration);
@@ -53,8 +75,8 @@ public class ProblemFormatter extends AbstractJavaFormatter {
                 doc.append(region.keyword("{"), it -> it.setNewLines(1, 1, 2));
                 doc.prepend(region.keyword("}"), it -> it.setNewLines(1, 1, 2));
                 doc.prepend(region.keyword("."), this::noSpace);
-                for (var referenceDeclaration : classDeclaration.getReferenceDeclarations()) {
-                        doc.format(referenceDeclaration);
+                for (var featureDeclaration : classDeclaration.getFeatureDeclarations()) {
+                        doc.format(featureDeclaration);
                 }
         }
 
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/NodeNameCollector.java b/subprojects/language/src/main/java/tools/refinery/language/resource/NodeNameCollector.java
index 99bf9b64..419be0d3 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/NodeNameCollector.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/NodeNameCollector.java
@@ -1,10 +1,9 @@
 package tools.refinery.language.resource;
 
-import java.util.List;
-import java.util.Set;
-
+import com.google.common.collect.ImmutableSet;
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.xtext.linking.impl.LinkingHelper;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.nodemodel.INode;
@@ -12,20 +11,12 @@ 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 com.google.common.collect.ImmutableSet;
-import com.google.inject.Inject;
-import com.google.inject.name.Named;
-
-import tools.refinery.language.model.problem.Assertion;
-import tools.refinery.language.model.problem.AssertionArgument;
-import tools.refinery.language.model.problem.NodeAssertionArgument;
-import tools.refinery.language.model.problem.NodeValueAssertion;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ProblemPackage;
-import tools.refinery.language.model.problem.Statement;
+import tools.refinery.language.model.problem.*;
 import tools.refinery.language.naming.NamingUtil;
 
+import java.util.List;
+import java.util.Set;
+
 public class NodeNameCollector {
         @Inject
         private LinkingHelper linkingHelper;
@@ -55,25 +46,20 @@ public class NodeNameCollector {
         protected void collectStatementNodeNames(Statement statement) {
                 if (statement instanceof Assertion assertion) {
                         collectAssertionNodeNames(assertion);
-                } else if (statement instanceof NodeValueAssertion nodeValueAssertion) {
-                        collectNodeValueAssertionNodeNames(nodeValueAssertion);
                 }
         }
 
         protected void collectAssertionNodeNames(Assertion assertion) {
                 for (AssertionArgument argument : assertion.getArguments()) {
                         if (argument instanceof NodeAssertionArgument) {
-                                collectNodeNames(argument, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
+                                collectNodeNames(argument);
                         }
                 }
         }
 
-        protected void collectNodeValueAssertionNodeNames(NodeValueAssertion nodeValueAssertion) {
-                collectNodeNames(nodeValueAssertion, ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE);
-        }
-
-        private void collectNodeNames(EObject eObject, EStructuralFeature feature) {
-                List<INode> nodes = NodeModelUtils.findNodesForFeature(eObject, feature);
+        private void collectNodeNames(EObject eObject) {
+                List<INode> nodes = NodeModelUtils.findNodesForFeature(eObject,
+                                ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
                 for (INode node : nodes) {
                         var nodeName = linkingHelper.getCrossRefNodeAsString(node, true);
                         if (!NamingUtil.isValidId(nodeName)) {
@@ -85,4 +71,4 @@ public class NodeNameCollector {
                         }
                 }
         }
-}
\ No newline at end of file
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemDerivedStateComputer.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemDerivedStateComputer.java
index f28e1791..8d3a552a 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemDerivedStateComputer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemDerivedStateComputer.java
@@ -1,13 +1,9 @@
 package tools.refinery.language.resource;
 
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.Function;
-
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import com.google.inject.Singleton;
+import com.google.inject.name.Named;
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
@@ -16,37 +12,20 @@ import org.eclipse.xtext.Constants;
 import org.eclipse.xtext.resource.DerivedStateAwareResource;
 import org.eclipse.xtext.resource.IDerivedStateComputer;
 import org.eclipse.xtext.resource.XtextResource;
-import org.eclipse.xtext.scoping.IScopeProvider;
-import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
-
-import com.google.inject.Inject;
-import com.google.inject.Provider;
-import com.google.inject.Singleton;
-import com.google.inject.name.Named;
+import tools.refinery.language.model.problem.*;
 
-import tools.refinery.language.model.problem.Assertion;
-import tools.refinery.language.model.problem.ClassDeclaration;
-import tools.refinery.language.model.problem.ConstantAssertionArgument;
-import tools.refinery.language.model.problem.Node;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ProblemFactory;
-import tools.refinery.language.model.problem.Statement;
+import java.util.*;
+import java.util.function.Function;
 
 @Singleton
 public class ProblemDerivedStateComputer implements IDerivedStateComputer {
         public static final String NEW_NODE = "new";
 
-        public static final String CONSTANT_NODE = "constant";
-
         @Inject
         @Named(Constants.LANGUAGE_NAME)
         private String languageName;
 
         @Inject
-        @Named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)
-        private IScopeProvider scopeProvider;
-
-        @Inject
         private Provider<NodeNameCollector> nodeNameCollectorProvider;
 
         @Inject
@@ -88,15 +67,6 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
                                         && declaration.getNewNode() == null) {
                                 var newNode = adapter.createNewNodeIfAbsent(declaration, key -> createNode(NEW_NODE));
                                 declaration.setNewNode(newNode);
-                        } else if (statement instanceof Assertion assertion) {
-                                for (var argument : assertion.getArguments()) {
-                                        if (argument instanceof ConstantAssertionArgument constantAssertionArgument
-                                                        && constantAssertionArgument.getNode() == null) {
-                                                var constantNode = adapter.createConstantNodeIfAbsent(constantAssertionArgument,
-                                                                key -> createNode(CONSTANT_NODE));
-                                                constantAssertionArgument.setNode(constantNode);
-                                        }
-                                }
                         }
                 }
         }
@@ -130,22 +100,14 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
 
         protected void discardDerivedProblemState(Problem problem, Adapter adapter) {
                 Set<ClassDeclaration> classDeclarations = new HashSet<>();
-                Set<ConstantAssertionArgument> constantAssertionArguments = new HashSet<>();
                 problem.getNodes().clear();
                 for (var statement : problem.getStatements()) {
                         if (statement instanceof ClassDeclaration classDeclaration) {
                                 classDeclaration.setNewNode(null);
                                 classDeclarations.add(classDeclaration);
-                        } else if (statement instanceof Assertion assertion) {
-                                for (var argument : assertion.getArguments()) {
-                                        if (argument instanceof ConstantAssertionArgument constantAssertionArgument) {
-                                                constantAssertionArgument.setNode(null);
-                                                constantAssertionArguments.add(constantAssertionArgument);
-                                        }
-                                }
                         }
                 }
-                adapter.retainAll(classDeclarations, constantAssertionArguments);
+                adapter.retainAll(classDeclarations);
                 derivedVariableComputer.discardDerivedVariables(problem);
         }
 
@@ -166,24 +128,15 @@ public class ProblemDerivedStateComputer implements IDerivedStateComputer {
         }
 
         protected static class Adapter extends AdapterImpl {
-                private Map<ClassDeclaration, Node> newNodes = new HashMap<>();
-
-                private Map<ConstantAssertionArgument, Node> constantNodes = new HashMap<>();
+                private final Map<ClassDeclaration, Node> newNodes = new HashMap<>();
 
                 public Node createNewNodeIfAbsent(ClassDeclaration classDeclaration,
                                 Function<ClassDeclaration, Node> createNode) {
                         return newNodes.computeIfAbsent(classDeclaration, createNode);
                 }
 
-                public Node createConstantNodeIfAbsent(ConstantAssertionArgument constantAssertionArgument,
-                                Function<ConstantAssertionArgument, Node> createNode) {
-                        return constantNodes.computeIfAbsent(constantAssertionArgument, createNode);
-                }
-
-                public void retainAll(Collection<ClassDeclaration> classDeclarations,
-                                Collection<ConstantAssertionArgument> constantAssertionArguments) {
+                public void retainAll(Collection<ClassDeclaration> classDeclarations) {
                         newNodes.keySet().retainAll(classDeclarations);
-                        constantNodes.keySet().retainAll(constantAssertionArguments);
                 }
 
                 @Override
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 c2045aea..3ab07496 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
@@ -29,8 +29,7 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
         @Override
         public IScope getScope(EObject context, EReference reference) {
                 var scope = super.getScope(context, reference);
-                if (reference == ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE
-                                || reference == ProblemPackage.Literals.NODE_VALUE_ASSERTION__NODE) {
+                if (reference == ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE) {
                         return getNodesScope(context, scope);
                 }
                 if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE
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
new file mode 100644
index 00000000..c51a5e28
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java
@@ -0,0 +1,52 @@
+package tools.refinery.language.serializer;
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.serializer.ISerializationContext;
+import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ListTransient;
+import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
+import tools.refinery.language.model.problem.Assertion;
+import tools.refinery.language.model.problem.LogicAssertionValue;
+import tools.refinery.language.model.problem.LogicValue;
+import tools.refinery.language.model.problem.ProblemPackage;
+import tools.refinery.language.services.ProblemGrammarAccess;
+
+public class PreferShortAssertionsProblemSemanticSequencer extends ProblemSemanticSequencer {
+        @Inject
+        private ProblemGrammarAccess grammarAccess;
+
+        @Override
+        protected void sequence_Assertion(ISerializationContext context, Assertion semanticObject) {
+                if (semanticObject.isDefault() ||
+                                !(semanticObject.getValue() instanceof LogicAssertionValue logicAssertionValue) ||
+                                logicAssertionValue.getLogicValue() == LogicValue.ERROR) {
+                        super.sequence_Assertion(context, semanticObject);
+                        return;
+                }
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.ASSERTION__RELATION) == ValueTransient.YES) {
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject,
+                                                ProblemPackage.Literals.ASSERTION__RELATION));
+                        }
+                        if (transientValues.isListTransient(semanticObject, ProblemPackage.Literals.ASSERTION__ARGUMENTS) == ListTransient.YES) {
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject,
+                                                ProblemPackage.Literals.ASSERTION__ARGUMENTS));
+                        }
+                }
+                var feeder = createSequencerFeeder(context, semanticObject);
+                var access = grammarAccess.getAssertionAccess();
+                feeder.accept(access.getValueShortLogicAssertionValueParserRuleCall_1_1_0_0(), logicAssertionValue);
+                feeder.accept(access.getRelationRelationQualifiedNameParserRuleCall_1_1_1_0_1(), semanticObject.getRelation());
+                var iterator = semanticObject.getArguments().iterator();
+                if (iterator.hasNext()) {
+                        var firstArgument = iterator.next();
+                        feeder.accept(access.getArgumentsAssertionArgumentParserRuleCall_1_1_3_0_0(), firstArgument, 0);
+                        int index = 1;
+                        while (iterator.hasNext()) {
+                                var argument = iterator.next();
+                                feeder.accept(access.getArgumentsAssertionArgumentParserRuleCall_1_1_3_1_1_0(), argument, index);
+                                index++;
+                        }
+                }
+                feeder.finish();
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java b/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java
index 7e43cecf..d3777cd3 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java
@@ -1,14 +1,8 @@
 package tools.refinery.language.utils;
 
-import tools.refinery.language.model.problem.ClassDeclaration;
-import tools.refinery.language.model.problem.EnumDeclaration;
-import tools.refinery.language.model.problem.Node;
-import tools.refinery.language.model.problem.PredicateDefinition;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ReferenceDeclaration;
+import tools.refinery.language.model.problem.*;
 
 public record BuiltinSymbols(Problem problem, ClassDeclaration node, ReferenceDeclaration equals,
-                PredicateDefinition exists, ClassDeclaration domain, ClassDeclaration data, EnumDeclaration bool, Node boolTrue,
-                Node boolFalse, ClassDeclaration intClass, ClassDeclaration real, ClassDeclaration string,
-                PredicateDefinition contained, PredicateDefinition contains, PredicateDefinition root) {
+                                                         PredicateDefinition exists, PredicateDefinition contained, PredicateDefinition contains,
+                                                         PredicateDefinition root) {
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/NodeInfo.java b/subprojects/language/src/main/java/tools/refinery/language/utils/NodeInfo.java
index 38db0e29..c8f47653 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/NodeInfo.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/NodeInfo.java
@@ -1,12 +1,4 @@
 package tools.refinery.language.utils;
 
-import java.util.ArrayList;
-import java.util.Collection;
-
-import tools.refinery.language.model.problem.NodeValueAssertion;
-
-public record NodeInfo(String name, boolean individual, Collection<NodeValueAssertion> valueAssertions) {
-        public NodeInfo(String name, boolean individual) {
-                this(name, individual, new ArrayList<>());
-        }
+public record NodeInfo(String name, boolean individual) {
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java
index 23fd8982..b8200919 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java
@@ -40,19 +40,10 @@ public class ProblemDesugarer {
                 var node = doGetDeclaration(builtin, ClassDeclaration.class, "node");
                 var equals = doGetEqualsReference(node);
                 var exists = doGetDeclaration(builtin, PredicateDefinition.class, "exists");
-                var domain = doGetDeclaration(builtin, ClassDeclaration.class, "domain");
-                var data = doGetDeclaration(builtin, ClassDeclaration.class, "data");
-                var bool = doGetDeclaration(builtin, EnumDeclaration.class, "bool");
-                var boolTrue = doGetLiteral(bool, "true");
-                var boolFalse = doGetLiteral(bool, "false");
-                var intClass = doGetDeclaration(builtin, ClassDeclaration.class, "int");
-                var real = doGetDeclaration(builtin, ClassDeclaration.class, "real");
-                var string = doGetDeclaration(builtin, ClassDeclaration.class, "string");
                 var contained = doGetDeclaration(builtin, PredicateDefinition.class, "contained");
                 var contains = doGetDeclaration(builtin, PredicateDefinition.class, "contains");
                 var root = doGetDeclaration(builtin, PredicateDefinition.class, "root");
-                return new BuiltinSymbols(builtin, node, equals, exists, domain, data, bool, boolTrue, boolFalse, intClass,
-                                real, string, contained, contains, root);
+                return new BuiltinSymbols(builtin, node, equals, exists, contained,     contains, root);
         }
 
         private <T extends Statement & NamedElement> T doGetDeclaration(Problem builtin, Class<T> type, String name) {
@@ -62,16 +53,12 @@ public class ProblemDesugarer {
         }
 
         private ReferenceDeclaration doGetEqualsReference(ClassDeclaration nodeClassDeclaration) {
-                return nodeClassDeclaration.getReferenceDeclarations().stream()
-                                .filter(reference -> "equals".equals(reference.getName())).findFirst()
+                return (ReferenceDeclaration) nodeClassDeclaration.getFeatureDeclarations().stream()
+                                .filter(reference -> reference instanceof ReferenceDeclaration &&
+                                                                "equals".equals(reference.getName())).findFirst()
                                 .orElseThrow(() -> new IllegalArgumentException("Reference " + "equals" + " not found"));
         }
 
-        private Node doGetLiteral(EnumDeclaration enumDeclaration, String name) {
-                return enumDeclaration.getLiterals().stream().filter(literal -> name.equals(literal.getName())).findFirst()
-                                .orElseThrow(() -> new IllegalArgumentException("Enum literal " + name + " not found"));
-        }
-
         public Collection<ClassDeclaration> getSuperclassesAndSelf(ClassDeclaration classDeclaration) {
                 return cache.get(Tuples.create(classDeclaration, "superclassesAndSelf"), classDeclaration.eResource(),
                                 () -> doGetSuperclassesAndSelf(classDeclaration));
@@ -94,9 +81,6 @@ public class ProblemDesugarer {
                                 }
                         }
                 }
-                if (builtinSymbols.isPresent() && !found.contains(builtinSymbols.get().data())) {
-                        found.add(builtinSymbols.get().domain());
-                }
                 return found;
         }
 
@@ -108,31 +92,17 @@ public class ProblemDesugarer {
         private Collection<ReferenceDeclaration> doGetAllReferenceDeclarations(ClassDeclaration classDeclaration) {
                 Set<ReferenceDeclaration> referenceDeclarations = new HashSet<>();
                 for (ClassDeclaration superclass : getSuperclassesAndSelf(classDeclaration)) {
-                        referenceDeclarations.addAll(superclass.getReferenceDeclarations());
+                        for (FeatureDeclaration featureDeclaration : superclass.getFeatureDeclarations()) {
+                                if (featureDeclaration instanceof ReferenceDeclaration referenceDeclaration) {
+                                        referenceDeclarations.add(referenceDeclaration);
+                                }
+                        }
                 }
                 return referenceDeclarations;
         }
 
         public boolean isContainmentReference(ReferenceDeclaration referenceDeclaration) {
-                switch (referenceDeclaration.getKind()) {
-                case REFERENCE, CONTAINER:
-                        return false;
-                case CONTAINMENT:
-                        return true;
-                case DEFAULT:
-                        return isDataClass(referenceDeclaration.getReferenceType());
-                default:
-                        throw new IllegalArgumentException("Unknown reference kind " + referenceDeclaration.getKind());
-                }
-        }
-
-        public boolean isDataClass(Relation relation) {
-                if (relation instanceof ClassDeclaration classDeclaration) {
-                        var supertypes = getSuperclassesAndSelf(classDeclaration);
-                        var builtinSymbols = getBuiltinSymbols(relation);
-                        return builtinSymbols.isPresent() && supertypes.contains(builtinSymbols.get().data());
-                }
-                return false;
+                return referenceDeclaration.getKind() == ReferenceKind.CONTAINMENT;
         }
 
         public CollectedSymbols collectSymbols(Problem problem) {
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java b/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java
index 210e96ab..5412f620 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java
@@ -2,7 +2,6 @@ package tools.refinery.language.utils;
 
 import com.google.inject.Inject;
 import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import tools.refinery.language.model.problem.*;
@@ -64,43 +63,65 @@ class SymbolCollector {
         }
 
         private void collectClass(ClassDeclaration classDeclaration) {
-                // node and domain classes are not contained by default, but every other type is
-                // contained, including data types.
-                var contained =
-                                classDeclaration != builtinSymbols.node() && classDeclaration != builtinSymbols.domain();
+                var contained = classDeclaration != builtinSymbols.node();
                 var containmentRole = contained ? ContainmentRole.CONTAINED : ContainmentRole.NONE;
                 var instanceParameter = ProblemFactory.eINSTANCE.createParameter();
                 instanceParameter.setName("instance");
                 var classInfo = new RelationInfo(getQualifiedNameString(classDeclaration), containmentRole,
                                 List.of(instanceParameter), null, null, List.of());
                 relations.put(classDeclaration, classInfo);
-                collectReferences(classDeclaration);
+                collectFeatures(classDeclaration);
         }
 
-        private void collectReferences(ClassDeclaration classDeclaration) {
-                for (var referenceDeclaration : classDeclaration.getReferenceDeclarations()) {
-                        var referenceRole = desugarer.isContainmentReference(referenceDeclaration) ?
-                                        ContainmentRole.CONTAINMENT :
-                                        ContainmentRole.NONE;
-                        var sourceParameter = ProblemFactory.eINSTANCE.createParameter();
-                        sourceParameter.setName("source");
-                        sourceParameter.setParameterType(classDeclaration);
-                        var targetParameter = ProblemFactory.eINSTANCE.createParameter();
-                        targetParameter.setName("target");
-                        var multiplicity = referenceDeclaration.getMultiplicity();
-                        if (multiplicity == null) {
-                                var exactMultiplicity = ProblemFactory.eINSTANCE.createExactMultiplicity();
-                                exactMultiplicity.setExactValue(1);
-                                multiplicity = exactMultiplicity;
+        private void collectFeatures(ClassDeclaration classDeclaration) {
+                for (var featureDeclaration : classDeclaration.getFeatureDeclarations()) {
+                        if (featureDeclaration instanceof ReferenceDeclaration referenceDeclaration) {
+                                collectReference(classDeclaration, referenceDeclaration);
+                        } else if (featureDeclaration instanceof AttributeDeclaration attributeDeclaration) {
+                                collectAttribute(classDeclaration, attributeDeclaration);
+                        } else if (featureDeclaration instanceof FlagDeclaration flagDeclaration) {
+                                collectFlag(classDeclaration, flagDeclaration);
+                        } else {
+                                throw new IllegalArgumentException("Unknown FeatureDeclaration: " + featureDeclaration);
                         }
-                        targetParameter.setParameterType(referenceDeclaration.getReferenceType());
-                        var referenceInfo = new RelationInfo(getQualifiedNameString(referenceDeclaration), referenceRole,
-                                        List.of(sourceParameter, targetParameter), multiplicity, referenceDeclaration.getOpposite(),
-                                        List.of());
-                        this.relations.put(referenceDeclaration, referenceInfo);
                 }
         }
 
+        private void collectReference(ClassDeclaration classDeclaration, ReferenceDeclaration referenceDeclaration) {
+                var referenceRole = desugarer.isContainmentReference(referenceDeclaration) ?
+                                ContainmentRole.CONTAINMENT :
+                                ContainmentRole.NONE;
+                var sourceParameter = ProblemFactory.eINSTANCE.createParameter();
+                sourceParameter.setName("source");
+                sourceParameter.setParameterType(classDeclaration);
+                var targetParameter = ProblemFactory.eINSTANCE.createParameter();
+                targetParameter.setName("target");
+                var multiplicity = referenceDeclaration.getMultiplicity();
+                if (multiplicity == null) {
+                        var exactMultiplicity = ProblemFactory.eINSTANCE.createExactMultiplicity();
+                        exactMultiplicity.setExactValue(1);
+                        multiplicity = exactMultiplicity;
+                }
+                targetParameter.setParameterType(referenceDeclaration.getReferenceType());
+                var referenceInfo = new RelationInfo(getQualifiedNameString(referenceDeclaration), referenceRole,
+                                List.of(sourceParameter, targetParameter), multiplicity, referenceDeclaration.getOpposite(),
+                                List.of());
+                this.relations.put(referenceDeclaration, referenceInfo);
+        }
+
+        private void collectAttribute(ClassDeclaration classDeclaration, AttributeDeclaration attributeDeclaration) {
+                // TODO Implement attribute handling.
+        }
+
+        private void collectFlag(ClassDeclaration classDeclaration, FlagDeclaration flagDeclaration) {
+                var parameter = ProblemFactory.eINSTANCE.createParameter();
+                parameter.setName("object");
+                parameter.setParameterType(classDeclaration);
+                var referenceInfo = new RelationInfo(getQualifiedNameString(flagDeclaration), ContainmentRole.NONE,
+                                List.of(parameter), null, null, List.of());
+                this.relations.put(flagDeclaration, referenceInfo);
+        }
+
         private void collectEnum(EnumDeclaration enumDeclaration) {
                 var instanceParameter = ProblemFactory.eINSTANCE.createParameter();
                 instanceParameter.setName("instance");
@@ -117,8 +138,6 @@ class SymbolCollector {
                                 collectNewNode(classDeclaration);
                         } else if (statement instanceof EnumDeclaration enumDeclaration) {
                                 collectEnumLiterals(enumDeclaration);
-                        } else if (statement instanceof Assertion assertion) {
-                                collectConstantNodes(assertion);
                         }
                 }
                 for (var node : problem.getNodes()) {
@@ -145,17 +164,6 @@ class SymbolCollector {
                 }
         }
 
-        private void collectConstantNodes(Assertion assertion) {
-                for (var argument : assertion.getArguments()) {
-                        if (argument instanceof ConstantAssertionArgument constantAssertionArgument) {
-                                var constantNode = constantAssertionArgument.getNode();
-                                if (constantNode != null) {
-                                        addNode(constantNode, false);
-                                }
-                        }
-                }
-        }
-
         private void addNode(Node node, boolean individual) {
                 var info = new NodeInfo(getQualifiedNameString(node), individual);
                 this.nodes.put(node, info);
@@ -173,8 +181,6 @@ class SymbolCollector {
                 for (var statement : problem.getStatements()) {
                         if (statement instanceof Assertion assertion) {
                                 collectAssertion(assertion);
-                        } else if (statement instanceof NodeValueAssertion nodeValueAssertion) {
-                                collectNodeValueAssertion(nodeValueAssertion);
                         } else if (statement instanceof PredicateDefinition predicateDefinition) {
                                 collectPredicateAssertion(predicateDefinition);
                         } else if (statement instanceof ClassDeclaration classDeclaration) {
@@ -196,48 +202,6 @@ class SymbolCollector {
                         return;
                 }
                 relationInfo.assertions().add(assertion);
-                for (var argument : assertion.getArguments()) {
-                        if (argument instanceof ConstantAssertionArgument constantAssertionArgument) {
-                                var constantNode = constantAssertionArgument.getNode();
-                                if (constantNode != null) {
-                                        var valueAssertion = ProblemFactory.eINSTANCE.createNodeValueAssertion();
-                                        valueAssertion.setNode(constantNode);
-                                        valueAssertion.setValue(EcoreUtil.copy(constantAssertionArgument.getConstant()));
-                                        collectNodeValueAssertion(valueAssertion);
-                                        var logicValue = assertion.getValue();
-                                        if (logicValue != LogicValue.TRUE) {
-                                                addAssertion(builtinSymbols.exists(), logicValue, constantNode);
-                                        }
-                                }
-                        }
-                }
-        }
-
-        private void collectNodeValueAssertion(NodeValueAssertion nodeValueAssertion) {
-                var node = nodeValueAssertion.getNode();
-                if (node == null) {
-                        return;
-                }
-                var nodeInfo = this.nodes.get(node);
-                if (nodeInfo == null) {
-                        throw new IllegalStateException("Node value assertion refers to unknown node");
-                }
-                nodeInfo.valueAssertions().add(nodeValueAssertion);
-                var constant = nodeValueAssertion.getValue();
-                if (constant == null) {
-                        return;
-                }
-                Relation dataType;
-                if (constant instanceof IntConstant) {
-                        dataType = builtinSymbols.intClass();
-                } else if (constant instanceof RealConstant) {
-                        dataType = builtinSymbols.real();
-                } else if (constant instanceof StringConstant) {
-                        dataType = builtinSymbols.string();
-                } else {
-                        throw new IllegalArgumentException("Unknown constant type");
-                }
-                addAssertion(dataType, LogicValue.TRUE, node);
         }
 
         private void collectPredicateAssertion(PredicateDefinition predicateDefinition) {
@@ -278,7 +242,9 @@ class SymbolCollector {
                         }
                         assertion.getArguments().add(argument);
                 }
-                assertion.setValue(logicValue);
+                var value = ProblemFactory.eINSTANCE.createLogicAssertionValue();
+                value.setLogicValue(logicValue);
+                assertion.setValue(value);
                 collectAssertion(assertion);
         }
 }