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