Browse Source

Apply review feedback, fix struct initialization token

Robin Maisch 4 years ago
parent
commit
7ffb23a545

+ 3 - 3
jplag.frontend.rust/README.md

@@ -1,6 +1,6 @@
-# JPlag Scala language frontend
+# JPlag Rust language frontend
 
-The JPlag Scala frontend allows the use of JPlag with submissions in Scala. <br>
+The JPlag Rust frontend allows the use of JPlag with submissions in Scala. <br>
 It is based on the [Rust ANTLR4 grammar](https://github.com/antlr/grammars-v4/tree/master/rust), licensed under MIT.
 
 ### Rust specification compatibility
@@ -37,7 +37,7 @@ or _etcetera_ pattern `..` is used to skip a number of elements, so that the ele
 the assigned object.
 
 These `let` pattern assignments can be replaced with a sequence of more basic assignments. This is a possible
-vulnerability of this frontend.
+problem of this frontend.
 
 #### Problem in Rust (2): `return` is optional
 

+ 81 - 79
jplag.frontend.rust/src/main/java/de/jplag/rust/JplagRustListener.java → jplag.frontend.rust/src/main/java/de/jplag/rust/JPlagRustListener.java

@@ -1,5 +1,6 @@
 package de.jplag.rust;
 
+import static de.jplag.rust.ParserState.Context.NONE;
 import static de.jplag.rust.RustTokenConstants.*;
 
 import java.util.Objects;
@@ -12,13 +13,13 @@ import org.antlr.v4.runtime.tree.*;
 import de.jplag.rust.grammar.RustParser;
 import de.jplag.rust.grammar.RustParserBaseListener;
 
-public class JplagRustListener extends RustParserBaseListener implements ParseTreeListener {
+public class JPlagRustListener extends RustParserBaseListener implements ParseTreeListener {
 
     private final RustParserAdapter parserAdapter;
 
     private final ParserState<RustContext> state = new ParserState<>();
 
-    public JplagRustListener(RustParserAdapter parserAdapter) {
+    public JPlagRustListener(RustParserAdapter parserAdapter) {
         this.parserAdapter = parserAdapter;
         state.enter(RustContext.FILE);
     }
@@ -57,13 +58,13 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitUseTree(RustParser.UseTreeContext context) {
-        state.leave(RustContext.USE_TREE);
+        state.leaveAsserted(RustContext.USE_TREE);
         super.exitUseTree(context);
     }
 
     @Override
     public void enterSimplePath(RustParser.SimplePathContext context) {
-        if (state.getCurrent() == RustContext.USE_TREE) {
+        if (state.getCurrentContext() == RustContext.USE_TREE) {
             if (context.parent.getChildCount() > 1 && context.parent.getChild(1).getText().equals("::")) {
                 // Not a leaf
                 return;
@@ -84,26 +85,26 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
     @Override
     public void enterStruct_(RustParser.Struct_Context context) {
         transformToken(STRUCT, context.getStart());
-        state.enter(RustContext.STRUCT_BODY);
+        state.enter(RustContext.STRUCT_DECLARATION_BODY);
         super.enterStruct_(context);
     }
 
     @Override
     public void exitStruct_(RustParser.Struct_Context context) {
-        state.leave(RustContext.STRUCT_BODY);
+        state.leaveAsserted(RustContext.STRUCT_DECLARATION_BODY);
         super.exitStruct_(context);
     }
 
     @Override
     public void enterStructExpression(RustParser.StructExpressionContext context) {
-        transformToken(STRUCT, context.getStart());
-        state.enter(RustContext.STRUCT_BODY);
+        transformToken(RustTokenConstants.STRUCT_INITIALISATION, context.getStart());
+        state.enter(RustContext.STRUCT_INITIALISATION);
         super.enterStructExpression(context);
     }
 
     @Override
     public void exitStructExpression(RustParser.StructExpressionContext context) {
-        state.leave(RustContext.STRUCT_BODY);
+        state.leaveAsserted(RustContext.STRUCT_INITIALISATION);
         super.exitStructExpression(context);
     }
 
@@ -115,20 +116,20 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void enterStructExprField(RustParser.StructExprFieldContext context) {
-        transformToken(STRUCT_FIELD, context.getStart());
+        transformToken(ARGUMENT, context.getStart(), context.getStop());
         super.enterStructExprField(context);
     }
 
     @Override
     public void enterStructPattern(RustParser.StructPatternContext context) {
         transformToken(STRUCT, context.getStart());
-        state.enter(RustContext.STRUCT_BODY);
+        state.enter(RustContext.STRUCT_DECLARATION_BODY);
         super.enterStructPattern(context);
     }
 
     @Override
     public void exitStructPattern(RustParser.StructPatternContext context) {
-        state.leave(RustContext.STRUCT_BODY);
+        state.leaveAsserted(RustContext.STRUCT_DECLARATION_BODY);
         super.exitStructPattern(context);
     }
 
@@ -138,6 +139,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
         super.enterStructPatternField(context);
     }
 
+
     @Override
     public void enterTupleExpression(RustParser.TupleExpressionContext context) {
         state.enter(RustContext.TUPLE);
@@ -152,14 +154,14 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitTupleExpression(RustParser.TupleExpressionContext ctx) {
-        state.maybeLeave(RustContext.REDUNDANT_TUPLE);
-        state.leave(RustContext.TUPLE);
+        state.leaveIfInContext(RustContext.REDUNDANT_TUPLE);
+        state.leaveAsserted(RustContext.TUPLE);
         super.exitTupleExpression(ctx);
     }
 
     @Override
     public void enterTupleField(RustParser.TupleFieldContext context) {
-        if (state.getCurrent() != RustContext.REDUNDANT_TUPLE) {
+        if (state.getCurrentContext() != RustContext.REDUNDANT_TUPLE) {
             transformToken(TUPLE_ELEMENT, context.getStart());
         }
         super.enterTupleField(context);
@@ -167,29 +169,26 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void enterTupleStructPattern(RustParser.TupleStructPatternContext context) {
-        transformToken(STRUCT, context.getStart());
-        state.enter(RustContext.STRUCT_BODY);
+        transformToken(STRUCT_INITIALISATION, context.getStart());
+        state.enter(RustContext.STRUCT_INITIALISATION);
         super.enterTupleStructPattern(context);
     }
 
     @Override
     public void exitTupleStructPattern(RustParser.TupleStructPatternContext context) {
-        state.leave(RustContext.STRUCT_BODY);
+        state.leaveAsserted(RustContext.STRUCT_INITIALISATION);
         super.exitTupleStructPattern(context);
     }
 
     @Override
     public void enterTupleStructItems(RustParser.TupleStructItemsContext context) {
         state.enter(RustContext.TUPLE_STRUCT_PATTERN);
-        if (context.getChildCount() <= 2)
-            state.enter(RustContext.REDUNDANT_TUPLE);
         super.enterTupleStructItems(context);
     }
 
     @Override
     public void exitTupleStructItems(RustParser.TupleStructItemsContext context) {
-        state.maybeLeave(RustContext.REDUNDANT_TUPLE);
-        state.leave(RustContext.TUPLE_STRUCT_PATTERN);
+        state.leaveAsserted(RustContext.TUPLE_STRUCT_PATTERN);
         super.exitTupleStructItems(context);
     }
 
@@ -201,7 +200,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitTuplePatternItems(RustParser.TuplePatternItemsContext context) {
-        state.leave(RustContext.TUPLE_PATTERN);
+        state.leaveAsserted(RustContext.TUPLE_PATTERN);
         super.exitTuplePatternItems(context);
     }
 
@@ -214,7 +213,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitUnion_(RustParser.Union_Context context) {
-        state.leave(RustContext.UNION_BODY);
+        state.leaveAsserted(RustContext.UNION_BODY);
         super.exitUnion_(context);
     }
 
@@ -227,7 +226,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitTrait_(RustParser.Trait_Context context) {
-        state.leave(RustContext.TRAIT_BODY);
+        state.leaveAsserted(RustContext.TRAIT_BODY);
         super.exitTrait_(context);
     }
 
@@ -246,7 +245,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitImplementation(RustParser.ImplementationContext context) {
-        state.leave(RustContext.IMPLEMENTATION_BODY);
+        state.leaveAsserted(RustContext.IMPLEMENTATION_BODY);
         super.exitImplementation(context);
     }
 
@@ -259,7 +258,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitEnumeration(RustParser.EnumerationContext context) {
-        state.leave(RustContext.ENUM_BODY);
+        state.leaveAsserted(RustContext.ENUM_BODY);
         super.exitEnumeration(context);
     }
 
@@ -271,7 +270,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitEnumItemTuple(RustParser.EnumItemTupleContext ctx) {
-        state.leave(RustContext.TUPLE);
+        state.leaveAsserted(RustContext.TUPLE);
         super.exitEnumItemTuple(ctx);
     }
 
@@ -290,7 +289,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitMacroRulesDefinition(RustParser.MacroRulesDefinitionContext context) {
-        state.leave(RustContext.MACRO_RULES_DEFINITION_BODY);
+        state.leaveAsserted(RustContext.MACRO_RULES_DEFINITION_BODY);
         super.exitMacroRulesDefinition(context);
     }
 
@@ -303,7 +302,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitMacroRule(RustParser.MacroRuleContext context) {
-        state.leave(RustContext.MACRO_RULE_BODY);
+        state.leaveAsserted(RustContext.MACRO_RULE_BODY);
         super.exitMacroRule(context);
     }
 
@@ -316,7 +315,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitMacroInvocationSemi(RustParser.MacroInvocationSemiContext context) {
-        state.leave(RustContext.MACRO_INVOCATION_BODY);
+        state.leaveAsserted(RustContext.MACRO_INVOCATION_BODY);
         super.exitMacroInvocationSemi(context);
     }
 
@@ -329,7 +328,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitMacroInvocation(RustParser.MacroInvocationContext context) {
-        state.leave(RustContext.MACRO_INVOCATION_BODY);
+        state.leaveAsserted(RustContext.MACRO_INVOCATION_BODY);
         super.exitMacroInvocation(context);
     }
 
@@ -342,7 +341,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitExternBlock(RustParser.ExternBlockContext context) {
-        state.leave(RustContext.EXTERN_BLOCK);
+        state.leaveAsserted(RustContext.EXTERN_BLOCK);
         super.exitExternBlock(context);
     }
 
@@ -354,7 +353,9 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void enterStaticItem(RustParser.StaticItemContext context) {
-        transformToken(STATIC_ITEM, context.getStart());
+        int tokenType = context.getParent() instanceof RustParser.ExternalItemContext ?
+                STATIC_ITEM : VARIABLE_DECLARATION;
+        transformToken(tokenType, context.getStart());
         super.enterStaticItem(context);
     }
 
@@ -369,7 +370,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitFunction_(RustParser.Function_Context context) {
-        state.leave(RustContext.FUNCTION_BODY, RustContext.PROCEDURE_BODY);
+        state.leaveAsserted(RustContext.FUNCTION_BODY, RustContext.PROCEDURE_BODY);
         super.exitFunction_(context);
     }
 
@@ -387,7 +388,9 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void enterGenericParam(RustParser.GenericParamContext context) {
-        transformToken(TYPE_PARAMETER, context.getStart(), context.getStop());
+        if (!(context.getParent().getParent() instanceof RustParser.ForLifetimesContext)) {
+            transformToken(TYPE_PARAMETER, context.getStart(), context.getStop());
+        }
         super.enterGenericParam(context);
     }
 
@@ -399,7 +402,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitExpressionWithBlock(RustParser.ExpressionWithBlockContext context) {
-        state.leave(RustContext.INNER_BLOCK);
+        state.leaveAsserted(RustContext.INNER_BLOCK);
         super.exitExpressionWithBlock(context);
     }
 
@@ -412,8 +415,8 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitIfExpression(RustParser.IfExpressionContext context) {
-        state.maybeLeave(RustContext.ELSE_BODY);
-        state.leave(RustContext.IF_BODY, RustContext.ELSE_BODY);
+        state.leaveIfInContext(RustContext.ELSE_BODY);
+        state.leaveAsserted(RustContext.IF_BODY, RustContext.ELSE_BODY);
         super.exitIfExpression(context);
     }
 
@@ -426,8 +429,8 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitIfLetExpression(RustParser.IfLetExpressionContext ctx) {
-        state.maybeLeave(RustContext.ELSE_BODY);
-        state.leave(RustContext.IF_BODY);
+        state.leaveIfInContext(RustContext.ELSE_BODY);
+        state.leaveAsserted(RustContext.IF_BODY);
         super.exitIfLetExpression(ctx);
     }
 
@@ -447,7 +450,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitInfiniteLoopExpression(RustParser.InfiniteLoopExpressionContext context) {
-        state.leave(RustContext.LOOP_BODY);
+        state.leaveAsserted(RustContext.LOOP_BODY);
         super.exitInfiniteLoopExpression(context);
     }
 
@@ -461,7 +464,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitPredicateLoopExpression(RustParser.PredicateLoopExpressionContext context) {
-        state.leave(RustContext.LOOP_BODY);
+        state.leaveAsserted(RustContext.LOOP_BODY);
         super.exitPredicateLoopExpression(context);
     }
 
@@ -475,7 +478,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitPredicatePatternLoopExpression(RustParser.PredicatePatternLoopExpressionContext context) {
-        state.leave(RustContext.LOOP_BODY);
+        state.leaveAsserted(RustContext.LOOP_BODY);
         super.exitPredicatePatternLoopExpression(context);
     }
 
@@ -489,7 +492,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitIteratorLoopExpression(RustParser.IteratorLoopExpressionContext context) {
-        state.leave(RustContext.FOR_BODY);
+        state.leaveAsserted(RustContext.FOR_BODY);
         super.exitIteratorLoopExpression(context);
     }
 
@@ -508,7 +511,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitMatchExpression(RustParser.MatchExpressionContext context) {
-        state.leave(RustContext.MATCH_BODY);
+        state.leaveAsserted(RustContext.MATCH_BODY);
         super.exitMatchExpression(context);
     }
 
@@ -538,7 +541,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitCallExpression(RustParser.CallExpressionContext ctx) {
-        state.leave(RustContext.CALL);
+        state.leaveAsserted(RustContext.CALL);
         super.exitCallExpression(ctx);
     }
 
@@ -550,7 +553,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitMethodCallExpression(RustParser.MethodCallExpressionContext ctx) {
-        state.leave(RustContext.CALL);
+        state.leaveAsserted(RustContext.CALL);
         super.exitMethodCallExpression(ctx);
     }
 
@@ -581,7 +584,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitTuplePattern(RustParser.TuplePatternContext context) {
-        state.leave(RustContext.TUPLE);
+        state.leaveAsserted(RustContext.TUPLE);
         super.exitTuplePattern(context);
     }
 
@@ -594,7 +597,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void exitClosureExpression(RustParser.ClosureExpressionContext context) {
-        state.leave(RustContext.CLOSURE_BODY);
+        state.leaveAsserted(RustContext.CLOSURE_BODY);
         super.exitClosureExpression(context);
     }
 
@@ -615,7 +618,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
         // may be return value
         RuleContext maybeFunctionBlock = context.parent.parent;
         boolean isImplicitReturnValue = maybeFunctionBlock instanceof RustParser.StatementsContext && (maybeFunctionBlock.getChildCount() == 1)
-                && (state.getCurrent() == RustContext.FUNCTION_BODY) && !(context.getChild(0) instanceof RustParser.ReturnExpressionContext);
+                && (state.getCurrentContext() == RustContext.FUNCTION_BODY) && !(context.getChild(0) instanceof RustParser.ReturnExpressionContext);
 
         if (isImplicitReturnValue) {
             transformToken(RETURN, context.getStart());
@@ -625,8 +628,8 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void enterPattern(RustParser.PatternContext context) {
-        switch (state.getCurrent()) {
-            case TUPLE_STRUCT_PATTERN -> transformToken(STRUCT_FIELD, context.getStart());
+        switch (state.getCurrentContext()) {
+            case TUPLE_STRUCT_PATTERN -> transformToken(ARGUMENT, context.getStart(), context.getStop());
             case TUPLE_PATTERN -> transformToken(TUPLE_ELEMENT, context.getStart());
             default -> {
             }
@@ -638,7 +641,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
     public void visitTerminal(TerminalNode node) {
         final Token token = node.getSymbol();
         final ParseTree parentNode = node.getParent();
-        RustContext stateContext = state.getCurrent();
+        RustContext stateContext = state.getCurrentContext();
         switch (node.getText()) {
             case "*" -> {
                 if (parentNode instanceof RustParser.UseTreeContext) {
@@ -651,16 +654,11 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
                 }
             }
             case "=" -> {
-                if (!(parentNode instanceof RustParser.AttrInputContext || parentNode instanceof RustParser.TypeParamContext
+                if (!(parentNode instanceof RustParser.AttrInputContext || parentNode instanceof RustParser.MacroPunctuationTokenContext || parentNode instanceof RustParser.TypeParamContext
                         || parentNode instanceof RustParser.GenericArgsBindingContext) && stateContext != RustContext.MACRO_INNER) {
                     transformToken(ASSIGNMENT, token);
                 }
             }
-            case ":" -> {
-                if (parentNode instanceof RustParser.StructExprFieldContext) {
-                    transformToken(ASSIGNMENT, token);
-                }
-            }
             case "{" -> {
                 int startType = stateContext.getStartType();
                 if (startType != NONE) {
@@ -681,8 +679,8 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
                 if (stateContext == RustContext.MACRO_INNER) {
                     // maybe this is the end of a macro invocation/definition
-                    state.leave(RustContext.MACRO_INNER);
-                    stateContext = state.getCurrent();
+                    state.leaveAsserted(RustContext.MACRO_INNER);
+                    stateContext = state.getCurrentContext();
                     if (stateContext == RustContext.MACRO_INVOCATION_BODY || stateContext == RustContext.MACRO_RULE_BODY) {
                         transformToken(stateContext.getEndType(), token);
                     }
@@ -690,7 +688,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
             }
             case "(" -> {
                 switch (stateContext) {
-                    case STRUCT_BODY -> transformToken(RustContext.STRUCT_BODY.getStartType(), token);
+                    case STRUCT_DECLARATION_BODY -> transformToken(RustContext.STRUCT_DECLARATION_BODY.getStartType(), token);
                     case TUPLE -> transformToken(RustContext.TUPLE.getStartType(), token);
                     case MACRO_INVOCATION_BODY -> {
                         transformToken(MACRO_INVOCATION_BODY_START, token);
@@ -704,14 +702,14 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
             }
             case ")" -> {
                 switch (stateContext) {
-                    case STRUCT_BODY -> transformToken(RustContext.STRUCT_BODY.getEndType(), token);
+                    case STRUCT_DECLARATION_BODY -> transformToken(RustContext.STRUCT_DECLARATION_BODY.getEndType(), token);
                     case TUPLE -> transformToken(RustContext.TUPLE.getEndType(), token);
                     case MACRO_INVOCATION_BODY -> {
                         /* do nothing */
                     }
                     case MACRO_INNER -> {
-                        state.leave(RustContext.MACRO_INNER);
-                        stateContext = state.getCurrent();
+                        state.leaveAsserted(RustContext.MACRO_INNER);
+                        stateContext = state.getCurrentContext();
                         if (stateContext == RustContext.MACRO_INVOCATION_BODY) {
                             transformToken(MACRO_INVOCATION_BODY_END, token);
                         }
@@ -738,8 +736,8 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
                         /* do nothing */
                     }
                     case MACRO_INNER -> {
-                        state.leave(RustContext.MACRO_INNER);
-                        stateContext = state.getCurrent();
+                        state.leaveAsserted(RustContext.MACRO_INNER);
+                        stateContext = state.getCurrentContext();
                         if (stateContext == RustContext.MACRO_INVOCATION_BODY) {
                             transformToken(MACRO_INVOCATION_BODY_END, token);
                         }
@@ -762,17 +760,14 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
 
     @Override
     public void enterType_(RustParser.Type_Context context) {
-        if (context.parent instanceof RustParser.GenericArgsTypesContext) {
-            transformToken(TYPE_ARGUMENT, context.getStart());
-        }
-
+        // No TYPE_ARGUMENT token here, only for generic method type arguments
         state.enter(RustContext.TYPE);
         super.enterType_(context);
     }
 
     @Override
     public void exitType_(RustParser.Type_Context context) {
-        state.leave(RustContext.TYPE);
+        state.leaveAsserted(RustContext.TYPE);
         super.exitType_(context);
     }
 
@@ -780,7 +775,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
     public void enterGenericArg(RustParser.GenericArgContext context) {
         // Only type arguments for methods, not for type expressions
         if (context.getParent().getParent() instanceof RustParser.PathInExpressionContext) {
-            transformToken(TYPE_ARGUMENT, context.getStart());
+            transformToken(TYPE_ARGUMENT, context.getStart(), context.getStop());
         }
         super.enterGenericArg(context);
     }
@@ -793,9 +788,9 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
             if (context.parent instanceof RustParser.ArrayElementsContext) {
                 transformToken(ARRAY_ELEMENT, expression.getStart());
             } else if (context.parent instanceof RustParser.CallParamsContext) {
-                transformToken(ARGUMENT, expression.getStart());
+                transformToken(ARGUMENT, expression.getStart(), expression.getStop());
             } else if (context.parent instanceof RustParser.TuplePatternItemsContext || context.parent instanceof RustParser.TupleElementsContext) {
-                if (state.getCurrent() == RustContext.REDUNDANT_TUPLE)
+                if (state.getCurrentContext() == RustContext.REDUNDANT_TUPLE)
                     return;
                 transformToken(TUPLE_ELEMENT, expression.getStart());
             } else if (context.parent instanceof RustParser.ClosureExpressionContext) {
@@ -817,6 +812,8 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
      * Implementation of Context for the Rust language
      */
     enum RustContext implements ParserState.Context {
+
+
         /**
          * This is used to make sure that the stack is not empty -> getCurrent() != null
          **/
@@ -827,7 +824,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
          **/
         FUNCTION_BODY(FUNCTION_BODY_START, FUNCTION_BODY_END),
         PROCEDURE_BODY(FUNCTION_BODY_START, FUNCTION_BODY_END),
-        STRUCT_BODY(STRUCT_BODY_BEGIN, STRUCT_BODY_END),
+        STRUCT_DECLARATION_BODY(STRUCT_BODY_START, STRUCT_BODY_END),
         IF_BODY(IF_BODY_START, IF_BODY_END),
         ELSE_BODY(ELSE_BODY_START, ELSE_BODY_END),
         LOOP_BODY(LOOP_BODY_START, LOOP_BODY_END),
@@ -836,7 +833,7 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
         ENUM_BODY(ENUM_BODY_START, ENUM_BODY_END),
         MACRO_RULES_DEFINITION_BODY(MACRO_RULES_DEFINITION_BODY_START, MACRO_RULES_DEFINITION_BODY_END),
         MACRO_RULE_BODY(MACRO_RULE_BODY_START, MACRO_RULE_BODY_END),
-        MACRO_INVOCATION_BODY(MACRO_INVOCATION_BODY_START, NONE),
+        MACRO_INVOCATION_BODY(MACRO_INVOCATION_BODY_START, MACRO_INVOCATION_BODY_END),
         IMPLEMENTATION_BODY(IMPLEMENTATION_BODY_START, IMPLEMENTATION_BODY_END),
         EXTERN_BLOCK(EXTERN_BLOCK_START, EXTERN_BLOCK_END),
         MODULE_BODY(MODULE_START, MODULE_END),
@@ -875,7 +872,12 @@ public class JplagRustListener extends RustParserBaseListener implements ParseTr
         /**
          * In this context, '(' should be assigned an APPLY token.
          */
-        CALL(NONE, NONE);
+        CALL(NONE, NONE),
+
+        /**
+         * This context should behave like a function call: No tokens for parentheses.
+         */
+        STRUCT_INITIALISATION(NONE, NONE);
 
         private final int startType;
         private final int endType;

+ 9 - 3
jplag.frontend.rust/src/main/java/de/jplag/rust/ParserState.java

@@ -31,7 +31,7 @@ public class ParserState<C extends ParserState.Context> {
      * @param contexts The contexts to expect to end here
      */
     @SafeVarargs
-    protected final void leave(C... contexts) {
+    protected final void leaveAsserted(C... contexts) {
         C topContext = blockContexts.pop();
         assert Arrays.stream(contexts).anyMatch(context -> context == topContext);
     }
@@ -40,7 +40,7 @@ public class ParserState<C extends ParserState.Context> {
      * Returns the current context.
      * @return the current context
      */
-    protected C getCurrent() {
+    protected C getCurrentContext() {
         return blockContexts.peek();
     }
 
@@ -48,7 +48,7 @@ public class ParserState<C extends ParserState.Context> {
      * Leaves the current context if it is the given one.
      * @param blockContext the context that may be expected to end here
      */
-    protected void maybeLeave(C blockContext) {
+    protected void leaveIfInContext(C blockContext) {
         if (blockContexts.peek() == blockContext) {
             blockContexts.pop();
         }
@@ -59,6 +59,12 @@ public class ParserState<C extends ParserState.Context> {
      * and an endType, designating the start and the end of the context as a TokenConstant.
      */
     protected interface Context {
+
+        /**
+         *  Used as start or end type to indicate that no token shall be added for this context.
+         */
+        int NONE = -1;
+
         /**
          * Returns the TokenConstant that marks the start of the Context.
          * @return the start type

+ 1 - 1
jplag.frontend.rust/src/main/java/de/jplag/rust/RustParserAdapter.java

@@ -58,7 +58,7 @@ public class RustParserAdapter extends AbstractParser {
             // Walk over the parse tree:
             for (int i = 0; i < entryContext.getChildCount(); i++) {
                 ParseTree parseTree = entryContext.getChild(i);
-                treeWalker.walk(new JplagRustListener(this), parseTree);
+                treeWalker.walk(new JPlagRustListener(this), parseTree);
             }
         } catch (IOException exception) {
             logger.error("Parsing Error in '" + fileName + "':" + File.separator, exception);

+ 2 - 1
jplag.frontend.rust/src/main/java/de/jplag/rust/RustToken.java

@@ -31,8 +31,9 @@ public class RustToken extends Token {
             case FUNCTION_BODY_END -> "}FUNC";
 
             case STRUCT -> "STRUCT";
-            case STRUCT_BODY_BEGIN -> "STRUCT{";
+            case STRUCT_BODY_START -> "STRUCT{";
             case STRUCT_BODY_END -> "}STRUCT";
+            case STRUCT_INITIALISATION -> "STRUCT()";
 
             case STRUCT_FIELD -> "FIELD";
 

+ 74 - 69
jplag.frontend.rust/src/main/java/de/jplag/rust/RustTokenConstants.java

@@ -3,7 +3,6 @@ package de.jplag.rust;
 import de.jplag.TokenConstants;
 
 public interface RustTokenConstants extends TokenConstants {
-    int NONE = -1;
 
     int INNER_ATTRIBUTE = 2;
     int OUTER_ATTRIBUTE = 3;
@@ -22,97 +21,103 @@ public interface RustTokenConstants extends TokenConstants {
     int FUNCTION_BODY_END = 13;
 
     int STRUCT = 14;
-    int STRUCT_BODY_BEGIN = 15;
+    int STRUCT_BODY_START = 15;
     int STRUCT_BODY_END = 16;
+    int STRUCT_INITIALISATION = 17;
 
-    int STRUCT_FIELD = 17;
 
-    int UNION = 18;
-    int UNION_BODY_START = 19;
-    int UNION_BODY_END = 20;
 
-    int TRAIT = 21;
-    int TRAIT_BODY_START = 22;
-    int TRAIT_BODY_END = 23;
+    int STRUCT_FIELD = 18;
 
-    int IMPLEMENTATION = 24;
-    int IMPLEMENTATION_BODY_START = 25;
-    int IMPLEMENTATION_BODY_END = 26;
+    int UNION = 19;
+    int UNION_BODY_START = 20;
+    int UNION_BODY_END = 21;
 
-    int ENUM = 27;
-    int ENUM_BODY_START = 28;
-    int ENUM_BODY_END = 29;
-    int ENUM_ITEM = 30;
+    int TRAIT = 22;
+    int TRAIT_BODY_START = 23;
+    int TRAIT_BODY_END = 24;
 
-    int MACRO_RULES_DEFINITION = 31;
-    int MACRO_RULES_DEFINITION_BODY_START = 32;
-    int MACRO_RULES_DEFINITION_BODY_END = 33;
+    int IMPLEMENTATION = 25;
+    int IMPLEMENTATION_BODY_START = 26;
+    int IMPLEMENTATION_BODY_END = 27;
 
-    int MACRO_RULE = 34;
-    int MACRO_RULE_BODY_START = 35;
-    int MACRO_RULE_BODY_END = 36;
+    int ENUM = 28;
+    int ENUM_BODY_START = 29;
+    int ENUM_BODY_END = 30;
+    int ENUM_ITEM = 31;
 
-    int MACRO_INVOCATION = 37;
-    int MACRO_INVOCATION_BODY_START = 38;
-    int MACRO_INVOCATION_BODY_END = 39;
+    int MACRO_RULES_DEFINITION = 32;
+    int MACRO_RULES_DEFINITION_BODY_START = 33;
+    int MACRO_RULES_DEFINITION_BODY_END = 34;
 
-    int EXTERN_BLOCK = 40;
-    int EXTERN_BLOCK_START = 41;
-    int EXTERN_BLOCK_END = 42;
-    int TYPE_ALIAS = 43;
-    int STATIC_ITEM = 44;
+    int MACRO_RULE = 35;
+    int MACRO_RULE_BODY_START = 36;
+    int MACRO_RULE_BODY_END = 37;
 
-    int EXTERN_CRATE = 45;
+    int MACRO_INVOCATION = 38;
+    int MACRO_INVOCATION_BODY_START = 39;
+    int MACRO_INVOCATION_BODY_END = 40;
 
-    int IF_STATEMENT = 46;
-    int IF_BODY_START = 47;
-    int IF_BODY_END = 48;
-    int ELSE_STATEMENT = 49;
-    int ELSE_BODY_START = 50;
-    int ELSE_BODY_END = 51;
+    int EXTERN_BLOCK = 41;
+    int EXTERN_BLOCK_START = 42;
+    int EXTERN_BLOCK_END = 43;
+    int TYPE_ALIAS = 44;
+    int STATIC_ITEM = 45;
 
-    int LABEL = 52;
-    int LOOP_STATEMENT = 53;
-    int LOOP_BODY_START = 54;
-    int LOOP_BODY_END = 55;
-    int FOR_STATEMENT = 56;
-    int FOR_BODY_START = 57;
-    int FOR_BODY_END = 58;
+    int EXTERN_CRATE = 46;
 
-    int BREAK = 59;
+    int IF_STATEMENT = 47;
+    int IF_BODY_START = 48;
+    int IF_BODY_END = 49;
+    int ELSE_STATEMENT = 50;
+    int ELSE_BODY_START = 51;
+    int ELSE_BODY_END = 52;
 
-    int MATCH_EXPRESSION = 60;
-    int MATCH_BODY_START = 61;
-    int MATCH_BODY_END = 62;
-    int MATCH_CASE = 63;
-    int MATCH_GUARD = 64;
 
-    int INNER_BLOCK_START = 65;
-    int INNER_BLOCK_END = 66;
+    int LABEL = 53;
+    int LOOP_STATEMENT = 54;
+    int LOOP_BODY_START = 55;
+    int LOOP_BODY_END = 56;
+    int FOR_STATEMENT = 57;
+    int FOR_BODY_START = 58;
+    int FOR_BODY_END = 59;
 
-    int ARRAY_BODY_START = 67;
-    int ARRAY_BODY_END = 68;
-    int ARRAY_ELEMENT = 69;
+    int BREAK = 60;
 
-    int TUPLE = 70;
-    int TUPLE_START = 71;
-    int TUPLE_END = 72;
-    int TUPLE_ELEMENT = 73;
+    int MATCH_EXPRESSION = 61;
+    int MATCH_BODY_START = 62;
+    int MATCH_BODY_END = 63;
+    int MATCH_CASE = 64;
+    int MATCH_GUARD = 65;
 
-    int CLOSURE = 74;
-    int CLOSURE_BODY_START = 75;
-    int CLOSURE_BODY_END = 76;
+    int INNER_BLOCK_START = 66;
+    int INNER_BLOCK_END = 67;
 
-    int APPLY = 77;
-    int ARGUMENT = 78;
-    int ASSIGNMENT = 79;
+    int ARRAY_BODY_START = 68;
+    int ARRAY_BODY_END = 69;
+    int ARRAY_ELEMENT = 70;
 
-    int VARIABLE_DECLARATION = 80;
+    int TUPLE = 71;
+    int TUPLE_START = 72;
+    int TUPLE_END = 73;
+    int TUPLE_ELEMENT = 74;
 
-    int TYPE_ARGUMENT = 81;
 
-    int RETURN = 82;
+    int CLOSURE = 75;
+    int CLOSURE_BODY_START = 76;
+    int CLOSURE_BODY_END = 77;
+
+    int APPLY = 78;
+    int ARGUMENT = 79;
+    int ASSIGNMENT = 80;
+
+    int VARIABLE_DECLARATION = 81;
+
+    int TYPE_ARGUMENT = 82;
+
+    int RETURN = 83;
+
+    int NUMBER_DIFF_TOKENS = 84;
 
-    int NUMBER_DIFF_TOKENS = 83;
 
 }