Synthetic tokens for solver language

2 files changed, 60 insertions, 115 deletions

diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
index fc204c16..5cb73796 100644
--- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
@@ -16,6 +16,7 @@ import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity;
 import org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition;

 import org.eclipse.viatra.solver.language.solverLanguage.Call;

 import org.eclipse.viatra.solver.language.solverLanguage.Case;

+import org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition;

 import org.eclipse.viatra.solver.language.solverLanguage.Comparison;

 import org.eclipse.viatra.solver.language.solverLanguage.Conjunction;

 import org.eclipse.viatra.solver.language.solverLanguage.Count;

@@ -43,7 +44,6 @@ import org.eclipse.viatra.solver.language.solverLanguage.Problem;
 import org.eclipse.viatra.solver.language.solverLanguage.Reference;

 import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;

 import org.eclipse.viatra.solver.language.solverLanguage.StarArgument;

-import org.eclipse.viatra.solver.language.solverLanguage.Statement;

 import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral;

 import org.eclipse.viatra.solver.language.solverLanguage.Switch;

 import org.eclipse.viatra.solver.language.solverLanguage.TypedArgument;

@@ -91,34 +91,8 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
                                 sequence_BoundedScopeDefinition(context, (BoundedScopeDefinition) semanticObject); 

                                 return; 

                         case SolverLanguagePackage.CALL:

-                                if (action == grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()

-                                                || action == grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()

-                                                || action == grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()

-                                                || rule == grammarAccess.getExpressionRule()

-                                                || rule == grammarAccess.getDisjunctiveExpressionRule()

-                                                || action == grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()

-                                                || action == grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()

-                                                || rule == grammarAccess.getConjunctiveExpressionRule()

-                                                || action == grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()

-                                                || rule == grammarAccess.getComparisonExpressionRule()

-                                                || action == grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()

-                                                || rule == grammarAccess.getAdditiveExpressionRule()

-                                                || action == grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()

-                                                || rule == grammarAccess.getMultiplicativeExpressionRule()

-                                                || action == grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()

-                                                || rule == grammarAccess.getExponentialExpressionRule()

-                                                || action == grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()

-                                                || rule == grammarAccess.getUnaryExpressionRule()

-                                                || rule == grammarAccess.getAggregationExpressionRule()

-                                                || rule == grammarAccess.getAtomicExpressionRule()) {

-                                        sequence_AtomicExpression(context, (Call) semanticObject); 

-                                        return; 

-                                }

-                                else if (rule == grammarAccess.getCallRule()) {

-                                        sequence_Call(context, (Call) semanticObject); 

-                                        return; 

-                                }

-                                else break;

+                                sequence_Call(context, (Call) semanticObject); 

+                                return; 

                         case SolverLanguagePackage.CASE:

                                 if (rule == grammarAccess.getCaseRule()) {

                                         sequence_Case(context, (Case) semanticObject); 

@@ -129,6 +103,9 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
                                         return; 

                                 }

                                 else break;

+                        case SolverLanguagePackage.CLASS_DEFINITION:

+                                sequence_ClassDefinition(context, (ClassDefinition) semanticObject); 

+                                return; 

                         case SolverLanguagePackage.COMPARISON:

                                 sequence_ComparisonExpression(context, (Comparison) semanticObject); 

                                 return; 

@@ -229,9 +206,6 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
                         case SolverLanguagePackage.STAR_ARGUMENT:

                                 sequence_StarArgument(context, (StarArgument) semanticObject); 

                                 return; 

-                        case SolverLanguagePackage.STATEMENT:

-                                sequence_ClassDefinition(context, (Statement) semanticObject); 

-                                return; 

                         case SolverLanguagePackage.STRING_LITERAL:

                                 sequence_StringLiteral(context, (StringLiteral) semanticObject); 

                                 return; 

@@ -430,46 +404,6 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
         

         /**

          * Contexts:

-         *     AssertionOrDefinition.Assertion_1_0_0 returns Call

-         *     AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call

-         *     AssertionOrDefinition.MetricDefinition_1_2_0 returns Call

-         *     Expression returns Call

-         *     DisjunctiveExpression returns Call

-         *     DisjunctiveExpression.Disjunction_1_0_0 returns Call

-         *     DisjunctiveExpression.Case_1_1_0 returns Call

-         *     ConjunctiveExpression returns Call

-         *     ConjunctiveExpression.Conjunction_1_0 returns Call

-         *     ComparisonExpression returns Call

-         *     ComparisonExpression.Comparison_1_0 returns Call

-         *     AdditiveExpression returns Call

-         *     AdditiveExpression.BinaryExpression_1_0 returns Call

-         *     MultiplicativeExpression returns Call

-         *     MultiplicativeExpression.BinaryExpression_1_0 returns Call

-         *     ExponentialExpression returns Call

-         *     ExponentialExpression.BinaryExpression_1_0 returns Call

-         *     UnaryExpression returns Call

-         *     AggregationExpression returns Call

-         *     AtomicExpression returns Call

-         *

-         * Constraint:

-         *     (functor=AtomicExpression_Call_0_1_0 argumentList=ArgumentList)

-         */

-        protected void sequence_AtomicExpression(ISerializationContext context, Call semanticObject) {

-                if (errorAcceptor != null) {

-                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CALL__FUNCTOR) == ValueTransient.YES)

-                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CALL__FUNCTOR));

-                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CALL__ARGUMENT_LIST) == ValueTransient.YES)

-                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CALL__ARGUMENT_LIST));

-                }

-                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);

-                feeder.accept(grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0(), semanticObject.getFunctor());

-                feeder.accept(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0(), semanticObject.getArgumentList());

-                feeder.finish();

-        }

-        

-        

-        /**

-         * Contexts:

          *     Multiplicity returns BoundedMultiplicity

          *     BoundedMultiplicity returns BoundedMultiplicity

          *

@@ -506,10 +440,34 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
         

         /**

          * Contexts:

+         *     AssertionOrDefinition.Assertion_1_0_0 returns Call

+         *     AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call

+         *     AssertionOrDefinition.MetricDefinition_1_2_0 returns Call

+         *     Expression returns Call

+         *     DisjunctiveExpression returns Call

+         *     DisjunctiveExpression.Disjunction_1_0_0 returns Call

+         *     DisjunctiveExpression.Case_1_1_0 returns Call

+         *     ConjunctiveExpression returns Call

+         *     ConjunctiveExpression.Conjunction_1_0 returns Call

+         *     ComparisonExpression returns Call

+         *     ComparisonExpression.Comparison_1_0 returns Call

+         *     AdditiveExpression returns Call

+         *     AdditiveExpression.BinaryExpression_1_0 returns Call

+         *     MultiplicativeExpression returns Call

+         *     MultiplicativeExpression.BinaryExpression_1_0 returns Call

+         *     ExponentialExpression returns Call

+         *     ExponentialExpression.BinaryExpression_1_0 returns Call

+         *     UnaryExpression returns Call

+         *     AggregationExpression returns Call

+         *     AtomicExpression returns Call

          *     Call returns Call

          *

          * Constraint:

-         *     (functor=Reference (transitiveClosure?=STAR | reflexiveTransitiveClosure?=PLUS)? argumentList=ArgumentList)

+         *     (

+         *         functor=Reference 

+         *         (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? 

+         *         argumentList=ArgumentList

+         *     )

          */

         protected void sequence_Call(ISerializationContext context, Call semanticObject) {

                 genericSequencer.createSequence(context, semanticObject);

@@ -539,8 +497,8 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
         

         /**

          * Contexts:

-         *     Statement returns Statement

-         *     ClassDefinition returns Statement

+         *     Statement returns ClassDefinition

+         *     ClassDefinition returns ClassDefinition

          *

          * Constraint:

          *     (

@@ -550,7 +508,7 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
          *         members+=MemberDefinition*

          *     )

          */

-        protected void sequence_ClassDefinition(ISerializationContext context, Statement semanticObject) {

+        protected void sequence_ClassDefinition(ISerializationContext context, ClassDefinition semanticObject) {

                 genericSequencer.createSequence(context, semanticObject);

         }

         

@@ -1252,7 +1210,6 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
          *     UnaryExpression returns Reference

          *     AggregationExpression returns Reference

          *     AtomicExpression returns Reference

-         *     AtomicExpression.Call_0_1_0 returns Reference

          *     Reference returns Reference

          *

          * Constraint:

diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java
index 861f2125..1fa1a820 100644
--- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java
@@ -20,58 +20,46 @@ import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer;
 public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer {

 

         protected SolverLanguageGrammarAccess grammarAccess;

-        protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_3_0_a;

-        protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_3_0_p;

+        protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_4_0_a;

+        protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_4_0_p;

         protected AbstractElementAlias match_MemberDefinition_SemicolonKeyword_5_q;

         

         @Inject

         protected void init(IGrammarAccess access) {

                 grammarAccess = (SolverLanguageGrammarAccess) access;

-                match_AtomicExpression_LeftParenthesisKeyword_3_0_a = new TokenAlias(true, true, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0());

-                match_AtomicExpression_LeftParenthesisKeyword_3_0_p = new TokenAlias(true, false, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0());

+                match_AtomicExpression_LeftParenthesisKeyword_4_0_a = new TokenAlias(true, true, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0());

+                match_AtomicExpression_LeftParenthesisKeyword_4_0_p = new TokenAlias(true, false, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0());

                 match_MemberDefinition_SemicolonKeyword_5_q = new TokenAlias(false, true, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5());

         }

         

         @Override

         protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) {

-                if (ruleCall.getRule() == grammarAccess.getDOTRule())

-                        return getDOTToken(semanticObject, ruleCall, node);

-                else if (ruleCall.getRule() == grammarAccess.getPLUSRule())

-                        return getPLUSToken(semanticObject, ruleCall, node);

-                else if (ruleCall.getRule() == grammarAccess.getSTARRule())

-                        return getSTARToken(semanticObject, ruleCall, node);

+                if (ruleCall.getRule() == grammarAccess.getFULL_STOPRule())

+                        return getFULL_STOPToken(semanticObject, ruleCall, node);

+                else if (ruleCall.getRule() == grammarAccess.getREFLEXIVE_TRANSITIVE_CLOSURERule())

+                        return getREFLEXIVE_TRANSITIVE_CLOSUREToken(semanticObject, ruleCall, node);

+                else if (ruleCall.getRule() == grammarAccess.getTRANSITIVE_CLOSURERule())

+                        return getTRANSITIVE_CLOSUREToken(semanticObject, ruleCall, node);

                 return "";

         }

         

         /**

-         * terminal DOT:

-         *      "synthetic::dot";

+         * Synthetic terminal rule. The concrete syntax is to be specified by clients.

+         * Defaults to the empty string.

          */

-        protected String getDOTToken(EObject semanticObject, RuleCall ruleCall, INode node) {

-                if (node != null)

-                        return getTokenText(node);

-                return "synthetic::dot";

-        }

+        protected String getFULL_STOPToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; }

         

         /**

-         * terminal PLUS:

-         *      "synthetic::plus";

+         * Synthetic terminal rule. The concrete syntax is to be specified by clients.

+         * Defaults to the empty string.

          */

-        protected String getPLUSToken(EObject semanticObject, RuleCall ruleCall, INode node) {

-                if (node != null)

-                        return getTokenText(node);

-                return "synthetic::plus";

-        }

+        protected String getREFLEXIVE_TRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; }

         

         /**

-         * terminal STAR:

-         *      "synthetic::star";

+         * Synthetic terminal rule. The concrete syntax is to be specified by clients.

+         * Defaults to the empty string.

          */

-        protected String getSTARToken(EObject semanticObject, RuleCall ruleCall, INode node) {

-                if (node != null)

-                        return getTokenText(node);

-                return "synthetic::star";

-        }

+        protected String getTRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; }

         

         @Override

         protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) {

@@ -79,10 +67,10 @@ public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer
                 List<INode> transitionNodes = collectNodes(fromNode, toNode);

                 for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {

                         List<INode> syntaxNodes = getNodesFor(transitionNodes, syntax);

-                        if (match_AtomicExpression_LeftParenthesisKeyword_3_0_a.equals(syntax))

-                                emit_AtomicExpression_LeftParenthesisKeyword_3_0_a(semanticObject, getLastNavigableState(), syntaxNodes);

-                        else if (match_AtomicExpression_LeftParenthesisKeyword_3_0_p.equals(syntax))

-                                emit_AtomicExpression_LeftParenthesisKeyword_3_0_p(semanticObject, getLastNavigableState(), syntaxNodes);

+                        if (match_AtomicExpression_LeftParenthesisKeyword_4_0_a.equals(syntax))

+                                emit_AtomicExpression_LeftParenthesisKeyword_4_0_a(semanticObject, getLastNavigableState(), syntaxNodes);

+                        else if (match_AtomicExpression_LeftParenthesisKeyword_4_0_p.equals(syntax))

+                                emit_AtomicExpression_LeftParenthesisKeyword_4_0_p(semanticObject, getLastNavigableState(), syntaxNodes);

                         else if (match_MemberDefinition_SemicolonKeyword_5_q.equals(syntax))

                                 emit_MemberDefinition_SemicolonKeyword_5_q(semanticObject, getLastNavigableState(), syntaxNodes);

                         else acceptNodes(getLastNavigableState(), syntaxNodes);

@@ -99,6 +87,7 @@ public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer
          *     (rule start) (ambiguity) 'empty' (rule start)

          *     (rule start) (ambiguity) 'if' condition=Expression

          *     (rule start) (ambiguity) 'inf' (rule start)

+         *     (rule start) (ambiguity) functor=Reference

          *     (rule start) (ambiguity) op=AggregationOp

          *     (rule start) (ambiguity) op=UnaryOp

          *     (rule start) (ambiguity) referred=[NamedElement|QualifiedName]

@@ -106,13 +95,12 @@ public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer
          *     (rule start) (ambiguity) value=Real

          *     (rule start) (ambiguity) value=STRING

          *     (rule start) (ambiguity) {BinaryExpression.left=}

-         *     (rule start) (ambiguity) {Call.functor=}

          *     (rule start) (ambiguity) {Comparison.left=}

          *     (rule start) (ambiguity) {Conjunction.children+=}

          *     (rule start) (ambiguity) {Disjunction.children+=}

          *     (rule start) (ambiguity) {Switch.cases+=}

          */

-        protected void emit_AtomicExpression_LeftParenthesisKeyword_3_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {

+        protected void emit_AtomicExpression_LeftParenthesisKeyword_4_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {

                 acceptNodes(transition, nodes);

         }

         

@@ -131,7 +119,7 @@ public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer
          *     (rule start) (ambiguity) {Disjunction.children+=}

          *     (rule start) (ambiguity) {Switch.cases+=}

          */

-        protected void emit_AtomicExpression_LeftParenthesisKeyword_3_0_p(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {

+        protected void emit_AtomicExpression_LeftParenthesisKeyword_4_0_p(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {

                 acceptNodes(transition, nodes);

         }