Simplify project layout

16 files changed, 1064 insertions, 0 deletions

diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2 b/language/src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2
new file mode 100644
index 00000000..76563e2c
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2
@@ -0,0 +1,59 @@
+module org.eclipse.viatra.solver.language.GenerateProblem
+
+import org.eclipse.xtext.xtext.generator.*
+import org.eclipse.xtext.xtext.generator.model.project.*
+
+var rootPath = ".."
+
+Workflow {
+        component = XtextGenerator {
+                configuration = {
+                        project = StandardProjectConfig {
+                                baseName = "language"
+                                rootPath = rootPath
+                                runtimeTest = {
+                                        enabled = true
+                                }
+                genericIde = {
+                    name = "language-ide"
+                }
+                                web = {
+                                        enabled = true
+                    name = "language-web"
+                                }
+                                mavenLayout = true
+                        }
+                        code = {
+                                encoding = "UTF-8"
+                                lineDelimiter = "\n"
+                                fileHeader = "/*\n * generated by Xtext \${version}\n */"
+                                preferXtendStubs = false
+                        }
+                }
+                
+                language = StandardLanguage {
+                        name = "org.eclipse.viatra.solver.language.Problem"
+                        fileExtensions = "problem"
+                        referencedResource = "platform:/resource/language-model/model/problem.genmodel"
+
+                        serializer = {
+                                generateStub = false
+                        }
+                        validator = {
+                                // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator"
+                                // Generates checks for @Deprecated grammar annotations, an IssueProvider and a corresponding PropertyPage
+                                generateDeprecationValidation = true
+                        }
+                        generator = {
+                                generateXtendStub = true
+                        }
+                        junitSupport = {
+                                junitVersion = "5"
+                        }
+                        webSupport = {
+                                framework = "CodeMirror"
+                                suppressPattern = "string_singleQuote"
+                        }
+                }
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext b/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext
new file mode 100644
index 00000000..5f8b35f3
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext
@@ -0,0 +1,116 @@
+grammar org.eclipse.viatra.solver.language.Problem with org.eclipse.xtext.common.Terminals
+
+import "http://www.eclipse.org/emf/2002/Ecore" as ecore
+import "http://www.eclipse.org/viatra/solver/language/model/Problem"
+
+Problem:
+        ("problem" name=Identifier ".")?
+        statements+=Statement*;
+
+Statement:
+        ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration;
+
+ClassDeclaration:
+        abstract?="abstract"? "class"
+        name=Identifier
+        ("extends" superTypes+=[Relation|QualifiedName] ("," superTypes+=[Relation|QualifiedName])*)?
+        ("{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" | ".");
+
+EnumDeclaration:
+        "enum"
+        name=Identifier
+        ("{" (literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? "}" | ".");
+
+EnumLiteral returns Node:
+        name=QuotedOrUnquotedId;
+
+ReferenceDeclaration:
+        (containment?="contains" | "refers")?
+        referenceType=[Relation|QualifiedName]
+        ("[" multiplicity=Multiplicity "]")?
+        name=Identifier
+        ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?;
+
+PredicateDefinition:
+        (error?="error" "pred"? | "pred")
+        name=Identifier
+        "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")"
+        (":-" bodies+=Conjunction (";" bodies+=Conjunction)*)?
+        ".";
+
+Parameter:
+        parameterType=[Relation|QualifiedName]? name=Identifier;
+
+Conjunction:
+        literals+=Literal ("," literals+=Literal)*;
+
+Literal:
+        Atom | NegativeLiteral;
+
+NegativeLiteral:
+        "!" atom=Atom;
+
+Atom:
+        relation=[Relation|QualifiedName]
+        transitiveClosure?="+"?
+        "(" (arguments+=Argument ("," arguments+=Argument)*)? ")";
+
+Argument:
+        variableOrNode=[VariableOrNode|QualifiedName];
+
+Assertion:
+        (relation=[Relation|QualifiedName]
+        "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")"
+        ":" value=LogicValue |
+        value=ShortLogicValue?
+        relation=[Relation|QualifiedName]
+        "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")")
+        ".";
+
+enum LogicValue:
+        TRUE="true" | FALSE="false" | UNKNOWN="unknown";
+
+enum ShortLogicValue returns LogicValue:
+        FALSE="!" | UNKNOWN="?";
+
+ScopeDeclaration:
+        "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* ".";
+
+TypeScope:
+        targetType=[ClassDeclaration]
+        (increment?="+=" | "=")
+        multiplicity=DefiniteMultiplicity;
+
+Multiplicity:
+        UnboundedMultiplicity | DefiniteMultiplicity;
+
+DefiniteMultiplicity returns Multiplicity:
+        RangeMultiplicity | ExactMultiplicity;
+
+UnboundedMultiplicity:
+        {UnboundedMultiplicity};
+
+RangeMultiplicity:
+        lowerBound=INT ".." upperBound=UpperBound;
+
+ExactMultiplicity:
+        exactValue=INT;
+
+UpperBound returns ecore::EInt:
+        INT | "*";
+
+QuotedOrUnquotedId:
+        QUOTED_ID | Identifier;
+
+QualifiedName:
+        QUOTED_ID | Identifier (":" Identifier)* (":" QUOTED_ID)?;
+
+Identifier:
+        ID | "true" | "false";
+
+@Override
+terminal STRING:
+        '"' ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | '"'))* '"';
+
+terminal QUOTED_ID:
+        "'" ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | "'"))* "'";
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemRuntimeModule.java b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemRuntimeModule.java
new file mode 100644
index 00000000..eb9ddd77
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemRuntimeModule.java
@@ -0,0 +1,80 @@
+/*
+ * generated by Xtext 2.25.0
+ */
+package org.eclipse.viatra.solver.language;
+
+import org.eclipse.viatra.solver.language.conversion.ProblemValueConverterService;
+import org.eclipse.viatra.solver.language.naming.ProblemQualifiedNameConverter;
+import org.eclipse.viatra.solver.language.resource.ProblemDerivedStateComputer;
+import org.eclipse.viatra.solver.language.resource.ProblemLocationInFileProvider;
+import org.eclipse.viatra.solver.language.resource.ProblemResourceDescriptionStrategy;
+import org.eclipse.viatra.solver.language.scoping.ProblemGlobalScopeProvider;
+import org.eclipse.viatra.solver.language.scoping.ProblemLocalScopeProvider;
+import org.eclipse.xtext.conversion.IValueConverterService;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+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.scoping.IGlobalScopeProvider;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+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;
+
+/**
+ * Use this class to register components to be used at runtime / without the
+ * Equinox extension registry.
+ */
+public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
+        public Class<? extends IQualifiedNameConverter> bindIQualifiedNameConverter() {
+                return ProblemQualifiedNameConverter.class;
+        }
+
+        public Class<? extends IDefaultResourceDescriptionStrategy> bindIDefaultResourceDescriptionStrategy() {
+                return ProblemResourceDescriptionStrategy.class;
+        }
+
+        @Override
+        public Class<? extends IValueConverterService> bindIValueConverterService() {
+                return ProblemValueConverterService.class;
+        }
+
+        @Override
+        public Class<? extends IGlobalScopeProvider> bindIGlobalScopeProvider() {
+                return ProblemGlobalScopeProvider.class;
+        }
+
+        @Override
+        public void configureIScopeProviderDelegate(Binder binder) {
+                binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE))
+                                .to(ProblemLocalScopeProvider.class);
+        }
+
+        @Override
+        public Class<? extends XtextResource> bindXtextResource() {
+                return DerivedStateAwareResource.class;
+        }
+
+        public Class<? extends IResourceDescription.Manager> bindIResourceDescription$Manager() {
+                return DerivedStateAwareResourceDescriptionManager.class;
+        }
+
+        public Class<? extends IResourceValidator> bindIResourceValidator() {
+                return DerivedStateAwareResourceValidator.class;
+        }
+
+        public Class<? extends IDerivedStateComputer> bindIDerivedStateComputer() {
+                return ProblemDerivedStateComputer.class;
+        }
+
+        public Class<? extends ILocationInFileProvider> bindILocationInFileProvider() {
+                return ProblemLocationInFileProvider.class;
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemStandaloneSetup.java b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemStandaloneSetup.java
new file mode 100644
index 00000000..5652f859
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemStandaloneSetup.java
@@ -0,0 +1,26 @@
+/*
+ * generated by Xtext 2.25.0
+ */
+package org.eclipse.viatra.solver.language;
+
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.viatra.solver.language.model.problem.ProblemPackage;
+
+import com.google.inject.Injector;
+
+/**
+ * Initialization support for running Xtext languages without Equinox extension registry.
+ */
+public class ProblemStandaloneSetup extends ProblemStandaloneSetupGenerated {
+
+        public static void doSetup() {
+                new ProblemStandaloneSetup().createInjectorAndDoEMFRegistration();
+        }
+        
+        @Override
+        public Injector createInjectorAndDoEMFRegistration() {
+                if (!EPackage.Registry.INSTANCE.containsKey(ProblemPackage.eNS_URI))
+                        EPackage.Registry.INSTANCE.put(ProblemPackage.eNS_URI, ProblemPackage.eINSTANCE);
+                return super.createInjectorAndDoEMFRegistration();
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java
new file mode 100644
index 00000000..09f062f5
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java
@@ -0,0 +1,98 @@
+package org.eclipse.viatra.solver.language;
+
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration;
+import org.eclipse.viatra.solver.language.model.problem.Node;
+import org.eclipse.viatra.solver.language.model.problem.Problem;
+import org.eclipse.viatra.solver.language.model.problem.ProblemPackage;
+import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration;
+import org.eclipse.viatra.solver.language.model.problem.Relation;
+import org.eclipse.viatra.solver.language.model.problem.Variable;
+import org.eclipse.viatra.solver.language.scoping.ProblemGlobalScopeProvider;
+
+import com.google.common.collect.ImmutableList;
+import com.google.inject.Singleton;
+
+@Singleton
+public final class ProblemUtil {
+        private ProblemUtil() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static final String SINGLETON_VARIABLE_PREFIX = "_";
+
+        public static final String ENUM_NODE_NAME_QUOTE = "'";
+
+        public static final String NODE_CLASS_NAME = "node";
+
+        public static boolean isSingletonVariableName(String name) {
+                return name != null && name.startsWith(SINGLETON_VARIABLE_PREFIX);
+        }
+
+        public static boolean isSingletonVariable(Variable variable) {
+                return variable.eContainingFeature() == ProblemPackage.Literals.ARGUMENT__SINGLETON_VARIABLE;
+        }
+
+        public static boolean isEnumLiteral(Node node) {
+                return node.eContainingFeature() == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS;
+        }
+        
+        public static boolean isEnumNode(Node node) {
+                String name = node.getName();
+                boolean isNameQuoted = name != null && name.startsWith(ENUM_NODE_NAME_QUOTE)
+                                && name.endsWith(ENUM_NODE_NAME_QUOTE);
+                return isNameQuoted || isEnumLiteral(node);
+        }
+
+        public static boolean isNewNode(Node node) {
+                return node.eContainingFeature() == ProblemPackage.Literals.CLASS_DECLARATION__NEW_NODE;
+        }
+
+        public static Optional<Problem> getBuiltInLibrary(EObject context) {
+                return Optional.ofNullable(context.eResource()).map(Resource::getResourceSet)
+                                .map(resourceSet -> resourceSet.getResource(ProblemGlobalScopeProvider.BULTIN_LIBRARY_URI, true))
+                                .map(Resource::getContents).filter(contents -> !contents.isEmpty()).map(contents -> contents.get(0))
+                                .filter(Problem.class::isInstance).map(Problem.class::cast);
+        }
+
+        public static Optional<ClassDeclaration> getNodeClassDeclaration(EObject context) {
+                return getBuiltInLibrary(context).flatMap(problem -> problem.getStatements().stream()
+                                .filter(ClassDeclaration.class::isInstance).map(ClassDeclaration.class::cast)
+                                .filter(declaration -> NODE_CLASS_NAME.equals(declaration.getName())).findFirst());
+        }
+
+        public static Collection<ClassDeclaration> getSuperclassesAndSelf(ClassDeclaration classDeclaration) {
+                Set<ClassDeclaration> found = new HashSet<>();
+                getNodeClassDeclaration(classDeclaration).ifPresent(found::add);
+                Deque<ClassDeclaration> queue = new ArrayDeque<>();
+                queue.addLast(classDeclaration);
+                while (!queue.isEmpty()) {
+                        ClassDeclaration current = queue.removeFirst();
+                        if (!found.contains(current)) {
+                                found.add(current);
+                                for (Relation superType : current.getSuperTypes()) {
+                                        if (superType instanceof ClassDeclaration) {
+                                                queue.addLast((ClassDeclaration) superType);
+                                        }
+                                }
+                        }
+                }
+                return found;
+        }
+
+        public static Collection<ReferenceDeclaration> getAllReferenceDeclarations(ClassDeclaration classDeclaration) {
+                ImmutableList.Builder<ReferenceDeclaration> builder = ImmutableList.builder();
+                for (ClassDeclaration superclass : getSuperclassesAndSelf(classDeclaration)) {
+                        builder.addAll(superclass.getReferenceDeclarations());
+                }
+                return builder.build();
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/conversion/ProblemValueConverterService.java b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/ProblemValueConverterService.java
new file mode 100644
index 00000000..4f5fd069
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/ProblemValueConverterService.java
@@ -0,0 +1,17 @@
+package org.eclipse.viatra.solver.language.conversion;
+
+import org.eclipse.xtext.common.services.DefaultTerminalConverters;
+import org.eclipse.xtext.conversion.IValueConverter;
+import org.eclipse.xtext.conversion.ValueConverter;
+
+import com.google.inject.Inject;
+
+public class ProblemValueConverterService extends DefaultTerminalConverters {
+        @Inject
+        private UpperBoundValueConverter upperBoundValueConverter;
+        
+        @ValueConverter(rule = "UpperBound")
+        public IValueConverter<Integer> UpperBound() {
+                return upperBoundValueConverter;
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/conversion/UpperBoundValueConverter.java b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/UpperBoundValueConverter.java
new file mode 100644
index 00000000..3111b69b
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/UpperBoundValueConverter.java
@@ -0,0 +1,35 @@
+package org.eclipse.viatra.solver.language.conversion;
+
+import org.eclipse.xtext.conversion.ValueConverterException;
+import org.eclipse.xtext.conversion.impl.AbstractValueConverter;
+import org.eclipse.xtext.conversion.impl.INTValueConverter;
+import org.eclipse.xtext.nodemodel.INode;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+@Singleton
+public class UpperBoundValueConverter extends AbstractValueConverter<Integer> {
+        public static final String INFINITY = "*";      
+        
+        @Inject
+        private INTValueConverter intValueConverter;
+        
+        @Override
+        public Integer toValue(String string, INode node) throws ValueConverterException {
+                if (INFINITY.equals(string)) {
+                        return -1;
+                } else {
+                        return intValueConverter.toValue(string, node);
+                }
+        }
+
+        @Override
+        public String toString(Integer value) throws ValueConverterException {
+                if (value < 0) {
+                        return INFINITY;
+                } else {
+                        return intValueConverter.toString(value);
+                }
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/generator/ProblemGenerator.xtend b/language/src/main/java/org/eclipse/viatra/solver/language/generator/ProblemGenerator.xtend
new file mode 100644
index 00000000..0930f244
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/generator/ProblemGenerator.xtend
@@ -0,0 +1,25 @@
+/*
+ * generated by Xtext 2.25.0
+ */
+package org.eclipse.viatra.solver.language.generator
+
+import org.eclipse.emf.ecore.resource.Resource
+import org.eclipse.xtext.generator.AbstractGenerator
+import org.eclipse.xtext.generator.IFileSystemAccess2
+import org.eclipse.xtext.generator.IGeneratorContext
+
+/**
+ * Generates code from your model files on save.
+ * 
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation
+ */
+class ProblemGenerator extends AbstractGenerator {
+
+        override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {
+//              fsa.generateFile('greetings.txt', 'People to greet: ' + 
+//                      resource.allContents
+//                              .filter(Greeting)
+//                              .map[name]
+//                              .join(', '))
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/naming/ProblemQualifiedNameConverter.java b/language/src/main/java/org/eclipse/viatra/solver/language/naming/ProblemQualifiedNameConverter.java
new file mode 100644
index 00000000..3cee31f3
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/naming/ProblemQualifiedNameConverter.java
@@ -0,0 +1,15 @@
+package org.eclipse.viatra.solver.language.naming;
+
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+
+import com.google.inject.Singleton;
+
+@Singleton
+public class ProblemQualifiedNameConverter extends IQualifiedNameConverter.DefaultImpl {
+        public static final String DELIMITER = ":";
+        
+        @Override
+        public String getDelimiter() {
+                return DELIMITER;
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java
new file mode 100644
index 00000000..b885ce0e
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java
@@ -0,0 +1,299 @@
+package org.eclipse.viatra.solver.language.resource;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.viatra.solver.language.ProblemUtil;
+import org.eclipse.viatra.solver.language.model.problem.Argument;
+import org.eclipse.viatra.solver.language.model.problem.Assertion;
+import org.eclipse.viatra.solver.language.model.problem.Atom;
+import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration;
+import org.eclipse.viatra.solver.language.model.problem.Conjunction;
+import org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier;
+import org.eclipse.viatra.solver.language.model.problem.ImplicitVariable;
+import org.eclipse.viatra.solver.language.model.problem.Literal;
+import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral;
+import org.eclipse.viatra.solver.language.model.problem.Node;
+import org.eclipse.viatra.solver.language.model.problem.Parameter;
+import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition;
+import org.eclipse.viatra.solver.language.model.problem.Problem;
+import org.eclipse.viatra.solver.language.model.problem.ProblemFactory;
+import org.eclipse.viatra.solver.language.model.problem.ProblemPackage;
+import org.eclipse.viatra.solver.language.model.problem.Statement;
+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.resource.DerivedStateAwareResource;
+import org.eclipse.xtext.resource.IDerivedStateComputer;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import com.google.inject.name.Named;
+
+@Singleton
+public class ProblemDerivedStateComputer implements IDerivedStateComputer {
+        public static final String NEW_NODE = "new";
+
+        private static final Pattern ID_REGEX = Pattern.compile("[_a-zA-Z][_0-9a-zA-Z]*");
+
+        private static final Pattern QUOTED_ID_REGEX = Pattern.compile("'(\\\\.|[^\\'])*'");
+
+        @Inject
+        private LinkingHelper linkingHelper;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        @Named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)
+        private IScopeProvider scopeProvider;
+
+        @Override
+        public void installDerivedState(DerivedStateAwareResource resource, boolean preLinkingPhase) {
+                for (EObject object : resource.getContents()) {
+                        if (object instanceof Problem) {
+                                installDerivedProblemState((Problem) object, preLinkingPhase);
+                        }
+                }
+        }
+
+        protected void installDerivedProblemState(Problem problem, boolean preLinkingPhase) {
+                installNewNodes(problem);
+                if (!preLinkingPhase) {
+                        installDerivedNodes(problem);
+                        for (Statement statement : problem.getStatements()) {
+                                if (statement instanceof PredicateDefinition) {
+                                        PredicateDefinition definition = (PredicateDefinition) statement;
+                                        installDerivedPredicateDefinitionState(definition);
+                                }
+                        }
+                }
+        }
+
+        protected void installNewNodes(Problem problem) {
+                for (Statement statement : problem.getStatements()) {
+                        if (statement instanceof ClassDeclaration) {
+                                ClassDeclaration declaration = (ClassDeclaration) statement;
+                                if (!declaration.isAbstract()) {
+                                        Node newNode = createNode(NEW_NODE);
+                                        declaration.setNewNode(newNode);
+                                }
+                        }
+                }
+        }
+
+        protected void installDerivedNodes(Problem problem) {
+                IScope nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__ARGUMENTS);
+                Set<String> nodeNames = new HashSet<>();
+                for (Statement statement : problem.getStatements()) {
+                        if (statement instanceof Assertion) {
+                                addNodeNames(nodeNames, nodeScope, statement, ProblemPackage.Literals.ASSERTION__ARGUMENTS,
+                                                ProblemDerivedStateComputer::validNodeName);
+                        } else if (statement instanceof PredicateDefinition) {
+                                PredicateDefinition predicateDefinition = (PredicateDefinition) statement;
+                                for (Conjunction body : predicateDefinition.getBodies()) {
+                                        for (Literal literal : body.getLiterals()) {
+                                                Atom atom = null;
+                                                if (literal instanceof Atom) {
+                                                        atom = (Atom) literal;
+                                                } else if (literal instanceof NegativeLiteral) {
+                                                        NegativeLiteral negativeLiteral = (NegativeLiteral) literal;
+                                                        atom = negativeLiteral.getAtom();
+                                                }
+                                                if (atom == null) {
+                                                        continue;
+                                                }
+                                                for (Argument argument : atom.getArguments()) {
+                                                        addNodeNames(nodeNames, nodeScope, argument,
+                                                                        ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE,
+                                                                        ProblemDerivedStateComputer::validQuotedId);
+                                                }
+                                        }
+                                }
+                        }
+                }
+                List<Node> grapNodes = problem.getNodes();
+                for (String nodeName : nodeNames) {
+                        Node graphNode = createNode(nodeName);
+                        grapNodes.add(graphNode);
+                }
+        }
+
+        private void addNodeNames(Set<String> nodeNames, IScope nodeScope, EObject eObject, EStructuralFeature feature,
+                        Predicate<String> condition) {
+                List<INode> nodes = NodeModelUtils.findNodesForFeature(eObject, feature);
+                for (INode node : nodes) {
+                        String nodeName = linkingHelper.getCrossRefNodeAsString(node, true);
+                        if (!condition.test(nodeName)) {
+                                continue;
+                        }
+                        QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(nodeName);
+                        if (!nodeNames.contains(nodeName) && nodeScope.getSingleElement(qualifiedName) == null) {
+                                nodeNames.add(nodeName);
+                        }
+                }
+        }
+
+        protected Node createNode(String name) {
+                Node node = ProblemFactory.eINSTANCE.createNode();
+                node.setName(name);
+                return node;
+        }
+
+        protected void installDerivedPredicateDefinitionState(PredicateDefinition definition) {
+                Set<String> parameterNames = new HashSet<>();
+                for (Parameter parameter : definition.getParameters()) {
+                        String name = parameter.getName();
+                        if (name != null) {
+                                parameterNames.add(name);
+                        }
+                }
+                for (Conjunction body : definition.getBodies()) {
+                        installDeriveConjunctionState(body, parameterNames);
+                }
+        }
+
+        protected void installDeriveConjunctionState(Conjunction conjunction, Set<String> knownVariables) {
+                Set<String> newVariables = new HashSet<>();
+                for (Literal literal : conjunction.getLiterals()) {
+                        if (literal instanceof Atom) {
+                                Atom atom = (Atom) literal;
+                                createSigletonVariablesAndCollectVariables(atom, knownVariables, newVariables);
+                        }
+                }
+                createVariables(conjunction, newVariables);
+                newVariables.addAll(knownVariables);
+                for (Literal literal : conjunction.getLiterals()) {
+                        if (literal instanceof NegativeLiteral) {
+                                NegativeLiteral negativeLiteral = (NegativeLiteral) literal;
+                                installDeriveNegativeLiteralState(negativeLiteral, newVariables);
+                        }
+                }
+        }
+
+        protected void installDeriveNegativeLiteralState(NegativeLiteral negativeLiteral, Set<String> knownVariables) {
+                Set<String> newVariables = new HashSet<>();
+                createSigletonVariablesAndCollectVariables(negativeLiteral.getAtom(), knownVariables, newVariables);
+                createVariables(negativeLiteral, newVariables);
+        }
+
+        protected void createSigletonVariablesAndCollectVariables(Atom atom, Set<String> knownVariables,
+                        Set<String> newVariables) {
+                IScope scope = scopeProvider.getScope(atom, ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE);
+                List<INode> nodes = NodeModelUtils.findNodesForFeature(atom, ProblemPackage.Literals.ATOM__ARGUMENTS);
+                int nodesSize = nodes.size();
+                List<Argument> arguments = atom.getArguments();
+                int argumentsSize = arguments.size();
+                for (int i = 0; i < nodesSize; i++) {
+                        INode node = nodes.get(i);
+                        String variableName = linkingHelper.getCrossRefNodeAsString(node, true);
+                        if (!validId(variableName)) {
+                                continue;
+                        }
+                        QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(variableName);
+                        if (scope.getSingleElement(qualifiedName) != null) {
+                                continue;
+                        }
+                        if (ProblemUtil.isSingletonVariableName(variableName)) {
+                                if (i < argumentsSize) {
+                                        createSingletonVariable(arguments.get(i), variableName);
+                                }
+                                continue;
+                        }
+                        if (!knownVariables.contains(variableName)) {
+                                newVariables.add(variableName);
+                        }
+                }
+        }
+
+        protected void createVariables(ExistentialQuantifier quantifier, Set<String> newVariables) {
+                for (String variableName : newVariables) {
+                        createVariable(quantifier, variableName);
+                }
+        }
+
+        protected void createVariable(ExistentialQuantifier quantifier, String variableName) {
+                if (validId(variableName)) {
+                        ImplicitVariable variable = createNamedVariable(variableName);
+                        quantifier.getImplicitVariables().add(variable);
+                }
+        }
+
+        protected void createSingletonVariable(Argument argument, String variableName) {
+                if (validId(variableName)) {
+                        ImplicitVariable variable = createNamedVariable(variableName);
+                        argument.setSingletonVariable(variable);
+                }
+        }
+
+        protected ImplicitVariable createNamedVariable(String variableName) {
+                ImplicitVariable variable = ProblemFactory.eINSTANCE.createImplicitVariable();
+                variable.setName(variableName);
+                return variable;
+        }
+
+        @Override
+        public void discardDerivedState(DerivedStateAwareResource resource) {
+                for (EObject object : resource.getContents()) {
+                        if (object instanceof Problem) {
+                                discardDerivedProblemState((Problem) object);
+                        }
+                }
+        }
+
+        protected void discardDerivedProblemState(Problem problem) {
+                problem.getNodes().clear();
+                for (Statement statement : problem.getStatements()) {
+                        if (statement instanceof ClassDeclaration) {
+                                ClassDeclaration classDeclaration = (ClassDeclaration) statement;
+                                classDeclaration.setNewNode(null);
+                        } else if (statement instanceof PredicateDefinition) {
+                                PredicateDefinition definition = (PredicateDefinition) statement;
+                                for (Conjunction body : definition.getBodies()) {
+                                        body.getImplicitVariables().clear();
+                                        for (Literal literal : body.getLiterals()) {
+                                                if (literal instanceof Atom) {
+                                                        discardDerivedAtomState((Atom) literal);
+                                                }
+                                                if (literal instanceof NegativeLiteral) {
+                                                        NegativeLiteral negativeLiteral = (NegativeLiteral) literal;
+                                                        negativeLiteral.getImplicitVariables().clear();
+                                                        discardDerivedAtomState(negativeLiteral.getAtom());
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+
+        protected void discardDerivedAtomState(Atom atom) {
+                if (atom == null) {
+                        return;
+                }
+                for (Argument argument : atom.getArguments()) {
+                        argument.setSingletonVariable(null);
+                }
+        }
+
+        protected static boolean validId(String name) {
+                return name != null && ID_REGEX.matcher(name).matches();
+        }
+
+        protected static boolean validQuotedId(String name) {
+                return name != null && QUOTED_ID_REGEX.matcher(name).matches();
+        }
+
+        protected static boolean validNodeName(String name) {
+                return validId(name) || validQuotedId(name);
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemLocationInFileProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemLocationInFileProvider.java
new file mode 100644
index 00000000..94dbdfee
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemLocationInFileProvider.java
@@ -0,0 +1,32 @@
+package org.eclipse.viatra.solver.language.resource;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.viatra.solver.language.ProblemUtil;
+import org.eclipse.viatra.solver.language.model.problem.ImplicitVariable;
+import org.eclipse.viatra.solver.language.model.problem.Node;
+import org.eclipse.xtext.resource.DefaultLocationInFileProvider;
+import org.eclipse.xtext.util.ITextRegion;
+
+public class ProblemLocationInFileProvider extends DefaultLocationInFileProvider {
+        @Override
+        protected ITextRegion doGetTextRegion(EObject obj, RegionDescription query) {
+                if (obj instanceof Node) {
+                        return getNodeTextRegion((Node) obj, query);
+                }
+                if (obj instanceof ImplicitVariable) {
+                        return ITextRegion.EMPTY_REGION;
+                }
+                return super.doGetTextRegion(obj, query);
+        }
+
+        protected ITextRegion getNodeTextRegion(Node node, RegionDescription query) {
+                if (ProblemUtil.isEnumLiteral(node)) {
+                        return super.doGetTextRegion(node, query);
+                }
+                if (ProblemUtil.isNewNode(node)) {
+                        EObject container = node.eContainer();
+                        return doGetTextRegion(container, query);
+                }
+                return ITextRegion.EMPTY_REGION;
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemResourceDescriptionStrategy.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemResourceDescriptionStrategy.java
new file mode 100644
index 00000000..edb25a1c
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemResourceDescriptionStrategy.java
@@ -0,0 +1,89 @@
+package org.eclipse.viatra.solver.language.resource;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.viatra.solver.language.ProblemUtil;
+import org.eclipse.viatra.solver.language.model.problem.NamedElement;
+import org.eclipse.viatra.solver.language.model.problem.Node;
+import org.eclipse.viatra.solver.language.model.problem.Problem;
+import org.eclipse.viatra.solver.language.model.problem.Variable;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.EObjectDescription;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.impl.DefaultResourceDescriptionStrategy;
+import org.eclipse.xtext.util.IAcceptor;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+@Singleton
+public class ProblemResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy {
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Override
+        public boolean createEObjectDescriptions(EObject eObject, IAcceptor<IEObjectDescription> acceptor) {
+                if (eObject instanceof Variable) {
+                        return false;
+                }
+                if (eObject instanceof NamedElement) {
+                        NamedElement namedElement = (NamedElement) eObject;
+                        String name = namedElement.getName();
+                        if (name == null || name.isEmpty()) {
+                                return true;
+                        }
+                        Problem problem = EcoreUtil2.getContainerOfType(namedElement, Problem.class);
+                        QualifiedName problemQualifiedName = null;
+                        if (problem != null) {
+                                String problemName = problem.getName();
+                                if (problemName != null && !problemName.isEmpty()) {
+                                        problemQualifiedName = qualifiedNameConverter.toQualifiedName(problemName);
+                                }
+                        }
+                        QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(namedElement.getName());
+                        boolean nameExported;
+                        if (shouldExportSimpleName(namedElement)) {
+                                acceptEObjectDescription(namedElement, problemQualifiedName, qualifiedName, acceptor);
+                                nameExported = true;
+                        } else {
+                                nameExported = false;
+                        }
+                        EObject parent = namedElement.eContainer();
+                        while (parent != null && parent != problem) {
+                                if (parent instanceof NamedElement) {
+                                        NamedElement namedParent = (NamedElement) parent;
+                                        String parentName = namedParent.getName();
+                                        if (parentName != null || !name.isEmpty()) {
+                                                QualifiedName parentQualifiedName = qualifiedNameConverter.toQualifiedName(parentName);
+                                                qualifiedName = parentQualifiedName.append(qualifiedName);
+                                                if (shouldExportSimpleName(parent)) {
+                                                        acceptEObjectDescription(namedElement, problemQualifiedName, qualifiedName, acceptor);
+                                                        nameExported = true;
+                                                } else {
+                                                        nameExported = false;
+                                                }
+                                        }
+                                }
+                                parent = parent.eContainer();
+                        }
+                        if (!nameExported) {
+                                acceptEObjectDescription(namedElement, problemQualifiedName, qualifiedName, acceptor);
+                        }
+                }
+                return true;
+        }
+
+        protected boolean shouldExportSimpleName(EObject eObject) {
+                if (eObject instanceof Node) {
+                        return !ProblemUtil.isNewNode((Node) eObject);
+                }
+                return true;
+        }
+
+        private void acceptEObjectDescription(EObject eObject, QualifiedName prefix, QualifiedName qualifiedName,
+                        IAcceptor<IEObjectDescription> acceptor) {
+                QualifiedName qualifiedNameWithPrefix = prefix == null ? qualifiedName : prefix.append(qualifiedName);
+                acceptor.accept(EObjectDescription.create(qualifiedNameWithPrefix, eObject));
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemGlobalScopeProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemGlobalScopeProvider.java
new file mode 100644
index 00000000..05da277a
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemGlobalScopeProvider.java
@@ -0,0 +1,25 @@
+package org.eclipse.viatra.solver.language.scoping;
+
+import java.util.LinkedHashSet;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.scoping.impl.ImportUriGlobalScopeProvider;
+
+public class ProblemGlobalScopeProvider extends ImportUriGlobalScopeProvider {
+        public static final String BUILTIN_LIBRARY_NAME = "builtin";
+
+        public static final URI BULTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME);
+
+        @Override
+        protected LinkedHashSet<URI> getImportedUris(Resource resource) {
+                LinkedHashSet<URI> importedUris = new LinkedHashSet<>();
+                importedUris.add(BULTIN_LIBRARY_URI);
+                return importedUris;
+        }
+
+        private static URI getLibraryUri(String libraryName) {
+                return URI.createURI(ProblemGlobalScopeProvider.class.getClassLoader()
+                                .getResource("org/eclipse/viatra/solver/language/" + libraryName + ".problem").toString());
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemLocalScopeProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemLocalScopeProvider.java
new file mode 100644
index 00000000..e832bb09
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemLocalScopeProvider.java
@@ -0,0 +1,40 @@
+package org.eclipse.viatra.solver.language.scoping;
+
+import java.util.List;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.IResourceDescriptionsProvider;
+import org.eclipse.xtext.resource.ISelectable;
+import org.eclipse.xtext.scoping.impl.ImportNormalizer;
+import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider;
+
+import com.google.inject.Inject;
+
+public class ProblemLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider {
+        private static final QualifiedName BUILTIN_LIBRARY_QUALIFIED_NAME = QualifiedName
+                        .create(ProblemGlobalScopeProvider.BUILTIN_LIBRARY_NAME);
+
+        @Inject
+        private IResourceDescriptionsProvider resourceDescriptionsProvider;
+
+        @Override
+        protected List<ImportNormalizer> getImplicitImports(boolean ignoreCase) {
+                return List.of(doCreateImportNormalizer(BUILTIN_LIBRARY_QUALIFIED_NAME, true, ignoreCase));
+        }
+
+        @Override
+        protected List<ImportNormalizer> getImportedNamespaceResolvers(EObject context, boolean ignoreCase) {
+                return List.of();
+        }
+
+        @Override
+        protected ISelectable internalGetAllDescriptions(Resource resource) {
+                // Force the use of ProblemResourceDescriptionStrategy to include all QualifiedNames of objects.
+                IResourceDescriptions resourceDescriptions = resourceDescriptionsProvider
+                                .getResourceDescriptions(resource.getResourceSet());
+                return resourceDescriptions.getResourceDescription(resource.getURI());
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java
new file mode 100644
index 00000000..fc4034ae
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java
@@ -0,0 +1,83 @@
+/*
+ * generated by Xtext 2.25.0
+ */
+package org.eclipse.viatra.solver.language.scoping;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.viatra.solver.language.ProblemUtil;
+import org.eclipse.viatra.solver.language.model.problem.Argument;
+import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration;
+import org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier;
+import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition;
+import org.eclipse.viatra.solver.language.model.problem.ProblemPackage;
+import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration;
+import org.eclipse.viatra.solver.language.model.problem.Relation;
+import org.eclipse.viatra.solver.language.model.problem.Variable;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.Scopes;
+
+/**
+ * This class contains custom scoping description.
+ * 
+ * See
+ * https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping
+ * on how and when to use it.
+ */
+public class ProblemScopeProvider extends AbstractProblemScopeProvider {
+
+        @Override
+        public IScope getScope(EObject context, EReference reference) {
+                IScope scope = super.getScope(context, reference);
+                if (reference == ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE) {
+                        return getVariableScope(context, scope);
+                } else if (reference == ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE) {
+                        return getOppositeScope(context, scope);
+                }
+                return scope;
+        }
+
+        protected IScope getVariableScope(EObject context, IScope delegateScope) {
+                List<Variable> variables = new ArrayList<>();
+                EObject currentContext = context;
+                if (context instanceof Argument) {
+                        Argument argument = (Argument) context;
+                        Variable singletonVariable = argument.getSingletonVariable();
+                        if (singletonVariable != null) {
+                                variables.add(singletonVariable);
+                        }
+                }
+                while (currentContext != null && !(currentContext instanceof PredicateDefinition)) {
+                        if (currentContext instanceof ExistentialQuantifier) {
+                                ExistentialQuantifier quantifier = (ExistentialQuantifier) currentContext;
+                                variables.addAll(quantifier.getImplicitVariables());
+                        }
+                        currentContext = currentContext.eContainer();
+                }
+                if (currentContext instanceof PredicateDefinition) {
+                        PredicateDefinition definition = (PredicateDefinition) currentContext;
+                        variables.addAll(definition.getParameters());
+                }
+                return Scopes.scopeFor(variables, delegateScope);
+        }
+
+        protected IScope getOppositeScope(EObject context, IScope delegateScope) {
+                ReferenceDeclaration referenceDeclaration = EcoreUtil2.getContainerOfType(context, ReferenceDeclaration.class);
+                if (referenceDeclaration == null) {
+                        return delegateScope;
+                }
+                Relation relation = referenceDeclaration.getReferenceType();
+                if (!(relation instanceof ClassDeclaration)) {
+                        return delegateScope;
+                }
+                ClassDeclaration classDeclaration = (ClassDeclaration) relation;
+                Collection<ReferenceDeclaration> referenceDeclarations = ProblemUtil
+                                .getAllReferenceDeclarations(classDeclaration);
+                return Scopes.scopeFor(referenceDeclarations, delegateScope);
+        }
+}
diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/validation/ProblemValidator.java b/language/src/main/java/org/eclipse/viatra/solver/language/validation/ProblemValidator.java
new file mode 100644
index 00000000..2b17e222
--- /dev/null
+++ b/language/src/main/java/org/eclipse/viatra/solver/language/validation/ProblemValidator.java
@@ -0,0 +1,25 @@
+/*
+ * generated by Xtext 2.25.0
+ */
+package org.eclipse.viatra.solver.language.validation;
+
+
+/**
+ * This class contains custom validation rules. 
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+public class ProblemValidator extends AbstractProblemValidator {
+        
+//      public static final String INVALID_NAME = "invalidName";
+//
+//      @Check
+//      public void checkGreetingStartsWithCapital(Greeting greeting) {
+//              if (!Character.isUpperCase(greeting.getName().charAt(0))) {
+//                      warning("Name should start with a capital",
+//                                      ProblemPackage.Literals.GREETING__NAME,
+//                                      INVALID_NAME);
+//              }
+//      }
+        
+}