From 9c578632f229f0508d5e777327aa3c79a56d80ef Mon Sep 17 00:00:00 2001 From: Mark Paluch Date: Thu, 28 Dec 2023 10:11:37 +0100 Subject: [PATCH] Add custom ANTLR template to avoid Maven Replacer plugin. Closes #3285 --- .../v4/tool/templates/codegen/Java/Java.stg | 1006 +++++++++++++++++ spring-data-jpa/pom.xml | 23 - .../repository/query/HqlParserUnitTests.java | 35 + 3 files changed, 1041 insertions(+), 23 deletions(-) create mode 100644 org/antlr/v4/tool/templates/codegen/Java/Java.stg create mode 100644 spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/query/HqlParserUnitTests.java diff --git a/org/antlr/v4/tool/templates/codegen/Java/Java.stg b/org/antlr/v4/tool/templates/codegen/Java/Java.stg new file mode 100644 index 0000000000..fc455cfa1d --- /dev/null +++ b/org/antlr/v4/tool/templates/codegen/Java/Java.stg @@ -0,0 +1,1006 @@ +/* + * [The "BSD license"] + * Copyright (c) 2012-2016 Terence Parr + * Copyright (c) 2012-2016 Sam Harwell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +javaTypeInitMap ::= [ + "int":"0", + "long":"0", + "float":"0.0f", + "double":"0.0", + "boolean":"false", + "byte":"0", + "short":"0", + "char":"0", + default:"null" // anything other than a primitive type is an object +] + +// args must be , + +ParserFile(file, parser, namedActions, contextSuperClass) ::= << + + +package ; + + +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + + +>> + +ListenerFile(file, header, namedActions) ::= << + + +package ; + +
+import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link }. + */ +interface Listener extends ParseTreeListener { + + * Enter a parse tree produced by the {@code \} + * labeled alternative in {@link #\}. + + * Enter a parse tree produced by {@link #\}. + + * @param ctx the parse tree + */ +void enter(.Context ctx); +/** + + * Exit a parse tree produced by the {@code \} + * labeled alternative in {@link #\}. + + * Exit a parse tree produced by {@link #\}. + + * @param ctx the parse tree + */ +void exit(.Context ctx);}; separator="\n"> +} +>> + +BaseListenerFile(file, header, namedActions) ::= << + + +package ; + +
+ +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link Listener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +@SuppressWarnings("CheckReturnValue") +class BaseListener implements Listener { + The default implementation does nothing.\

+ */ +@Override public void enter(.Context ctx) { \} +/** + * {@inheritDoc\} + * + * \

The default implementation does nothing.\

+ */ +@Override public void exit(.Context ctx) { \}}; separator="\n"> + + /** + * {@inheritDoc\} + * + * \

The default implementation does nothing.\

+ */ + @Override public void enterEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc\} + * + * \

The default implementation does nothing.\

+ */ + @Override public void exitEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc\} + * + * \

The default implementation does nothing.\

+ */ + @Override public void visitTerminal(TerminalNode node) { } + /** + * {@inheritDoc\} + * + * \

The default implementation does nothing.\

+ */ + @Override public void visitErrorNode(ErrorNode node) { } +} +>> + +VisitorFile(file, header, namedActions) ::= << + + +package ; + +
+import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by {@link }. + * + * @param \ The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +interface Visitor\ extends ParseTreeVisitor\ { + + * Visit a parse tree produced by the {@code \} + * labeled alternative in {@link #\}. + + * Visit a parse tree produced by {@link #\}. + + * @param ctx the parse tree + * @return the visitor result + */ +T visit(.Context ctx);}; separator="\n"> +} +>> + +BaseVisitorFile(file, header, namedActions) ::= << + + +package ; + +
+import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link Visitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param \ The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +@SuppressWarnings("CheckReturnValue") +class BaseVisitor\ extends AbstractParseTreeVisitor\ implements Visitor\ { + The default implementation returns the result of calling + * {@link #visitChildren\} on {@code ctx\}.\

+ */ +@Override public T visit(.Context ctx) { return visitChildren(ctx); \}}; separator="\n"> +} +>> + +fileHeader(grammarFileName, ANTLRVersion) ::= << +// Generated from by ANTLR +>> + +Parser(parser, funcs, atn, sempredFuncs, superClass) ::= << + +>> + +Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= << +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +class extends { + // Customization: Suppress version check + // static { RuntimeMetaData.checkVersion("", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + + public static final int + =}; separator=", ", wrap, anchor>; + + + public static final int + = }; separator=", ", wrap, anchor>; + + private static String[] makeRuleNames() { + return new String[] { + "}; separator=", ", wrap, anchor> + }; + } + public static final String[] ruleNames = makeRuleNames(); + + + + @Override + public String getGrammarFileName() { return ""; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + + + + + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + : + return _sempred(()_localctx, predIndex);}; separator="\n"> + } + return true; + } + + + + +} +>> + +vocabulary(literalNames, symbolicNames) ::= << +private static String[] makeLiteralNames() { + return new String[] { + }; null="null", separator=", ", wrap, anchor> + }; +} +private static final String[] _LITERAL_NAMES = makeLiteralNames(); +private static String[] makeSymbolicNames() { + return new String[] { + }; null="null", separator=", ", wrap, anchor> + }; +} +private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); +public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + +/** + * @deprecated Use {@link #VOCABULARY} instead. + */ +@Deprecated +public static final String[] tokenNames; +static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i \< tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = "\"; + } + } +} + +@Override +@Deprecated +public String[] getTokenNames() { + return tokenNames; +} + +@Override + +public Vocabulary getVocabulary() { + return VOCABULARY; +} +>> + +dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= << + +@Override +public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + : + _action(()_localctx, actionIndex); + break;}; separator="\n"> + } +} + + + +@Override +public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + : + return _sempred(()_localctx, predIndex);}; separator="\n"> + } + return true; +} + + +>> + +parser_ctor(p) ::= << +public (TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); +} +>> + +/* This generates a private method since the actionIndex is generated, making an + * overriding implementation impossible to maintain. + */ +RuleActionFunction(r, actions) ::= << +private void _action( _localctx, int actionIndex) { + switch (actionIndex) { + : + + break;}; separator="\n"> + } +} +>> + +/* This generates a private method since the predIndex is generated, making an + * overriding implementation impossible to maintain. + */ +RuleSempredFunction(r, actions) ::= << +private boolean _sempred( _localctx, int predIndex) { + switch (predIndex) { + : + return ;}; separator="\n"> + } + return true; +} +>> + +RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= << + + +}; separator="\n"> + + }>public final () throws RecognitionException { + _localctx = new (_ctx, getState()}>); + enterRule(_localctx, , RULE_); + + + try { + + int _alt; + + + + + } + + + + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + + finally { + + exitRule(); + } + return _localctx; +} +>> + +LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs, + namedActions,finallyAction,postamble) ::= +<< + + +}; separator="\n"> + + }>public final () throws RecognitionException { + return (0}>); +} + +private (int _p}>) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + _localctx = new (_ctx, _parentState}>); + _prevctx = _localctx; + int _startState = ; + enterRecursionRule(_localctx, , RULE_, _p); + + + try { + + int _alt; + + + + + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + + unrollRecursionContexts(_parentctx); + } + return _localctx; +} +>> + +CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= << +_localctx = new Context(_localctx); +enterOuterAlt(_localctx, ); + +>> + +CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= << +{ + + + +} +>> + +LL1AltBlock(choice, preamble, alts, error) ::= << +setState(); +_errHandler.sync(this); + = _input.LT(1); + +switch (_input.LA(1)) { + + + break;}; separator="\n"> +default: + +} +>> + +LL1OptionalBlock(choice, alts, error) ::= << +setState(); +_errHandler.sync(this); +switch (_input.LA(1)) { + + + break;}; separator="\n"> +default: + break; +} +>> + +LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= << +setState(); +_errHandler.sync(this); + +if () { + +} +) ) !> +>> + +LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= << +setState(); +_errHandler.sync(this); + +while () { + + setState(); + _errHandler.sync(this); + +} +>> + +LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= << +setState(); +_errHandler.sync(this); + +do { + + setState(); + _errHandler.sync(this); + +} while ( ); +>> + +// LL(*) stuff + +AltBlock(choice, preamble, alts, error) ::= << +setState(); +_errHandler.sync(this); + = _input.LT(1); + +switch ( getInterpreter().adaptivePredict(_input,,_ctx) ) { +: + + break;}; separator="\n"> +} +>> + +OptionalBlock(choice, alts, error) ::= << +setState(); +_errHandler.sync(this); +switch ( getInterpreter().adaptivePredict(_input,,_ctx) ) { ++1: + + break;}; separator="\n"> +} +>> + +StarBlock(choice, alts, sync, iteration) ::= << +setState(); +_errHandler.sync(this); +_alt = getInterpreter().adaptivePredict(_input,,_ctx); +while ( _alt!= && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1+1 ) { + + + } + setState(); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,,_ctx); +} +>> + +PlusBlock(choice, alts, error) ::= << +setState(); +_errHandler.sync(this); +_alt = 1+1; +do { + switch (_alt) { + +1: + + break;}; separator="\n"> + default: + + } + setState(); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,,_ctx); +} while ( _alt!= && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); +>> + +Sync(s) ::= "sync();" + +ThrowNoViableAlt(t) ::= "throw new NoViableAltException(this);" + +TestSetInline(s) ::= << +}; separator=" || "> +>> + +// Java language spec 15.19 - shift operators mask operands rather than overflow to 0... need range test +testShiftInRange(shiftAmount) ::= << +(() & ~0x3f) == 0 +>> + +bitsetBitfieldComparison(s, bits) ::= <% +(})> && ((1L \<\< ) & L) != 0) +%> + +isZero ::= [ +"0":true, +default:false +] + +offsetShift(shiftAmount, offset) ::= <% +( - ) +%> + +bitsetInlineComparison(s, bits) ::= <% +==}; separator=" || "> +%> + +cases(tokens) ::= << +:}; separator="\n"> +>> + +InvokeRule(r, argExprsChunks) ::= << +setState(); + = }>(,); +>> + +MatchToken(m) ::= << +setState(); + = }>match(); +>> + +MatchSet(m, expr, capture) ::= "" + +MatchNotSet(m, expr, capture) ::= "" + +CommonSetStuff(m, expr, capture, invert) ::= << +setState(); + = }>_input.LT(1); + +if ( \<= 0 || !() ) { + = (Token)}>_errHandler.recoverInline(this); +} +else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); +} +>> + +Wildcard(w) ::= << +setState(); + = }>matchWildcard(); +>> + +// ACTION STUFF + +Action(a, foo, chunks) ::= "" + +ArgAction(a, chunks) ::= "" + +SemPred(p, chunks, failChunks) ::= << +setState(); +if (!()) throw new FailedPredicateException(this, , , ); +>> + +ExceptionClause(e, catchArg, catchAction) ::= << +catch () { + +} +>> + +// lexer actions are not associated with model objects + +LexerSkipCommand() ::= "skip();" +LexerMoreCommand() ::= "more();" +LexerPopModeCommand() ::= "popMode();" + +LexerTypeCommand(arg, grammar) ::= "_type = ;" +LexerChannelCommand(arg, grammar) ::= "_channel = ;" +LexerModeCommand(arg, grammar) ::= "_mode = ;" +LexerPushModeCommand(arg, grammar) ::= "pushMode();" + +ActionText(t) ::= "" +ActionTemplate(t) ::= "" +ArgRef(a) ::= "_localctx." +LocalRef(a) ::= "_localctx." +RetValueRef(a) ::= "_localctx." +QRetValueRef(a) ::= ".." +/** How to translate $tokenLabel */ +TokenRef(t) ::= "." +LabelRef(t) ::= "." +ListLabelRef(t) ::= "." +SetAttr(s,rhsChunks) ::= ". = ;" + +TokenLabelType() ::= "" +InputSymbolType() ::= "" + +TokenPropertyRef_text(t) ::= "(.!=null?..getText():null)" +TokenPropertyRef_type(t) ::= "(.!=null?..getType():0)" +TokenPropertyRef_line(t) ::= "(.!=null?..getLine():0)" +TokenPropertyRef_pos(t) ::= "(.!=null?..getCharPositionInLine():0)" +TokenPropertyRef_channel(t) ::= "(.!=null?..getChannel():0)" +TokenPropertyRef_index(t) ::= "(.!=null?..getTokenIndex():0)" +TokenPropertyRef_int(t) ::= "(.!=null?Integer.valueOf(..getText()):0)" + +RulePropertyRef_start(r) ::= "(.!=null?(..start):null)" +RulePropertyRef_stop(r) ::= "(.!=null?(..stop):null)" +RulePropertyRef_text(r) ::= "(.!=null?_input.getText(..start,..stop):null)" +RulePropertyRef_ctx(r) ::= "." +RulePropertyRef_parser(r) ::= "this" + +ThisRulePropertyRef_start(r) ::= "_localctx.start" +ThisRulePropertyRef_stop(r) ::= "_localctx.stop" +ThisRulePropertyRef_text(r) ::= "_input.getText(_localctx.start, _input.LT(-1))" +ThisRulePropertyRef_ctx(r) ::= "_localctx" +ThisRulePropertyRef_parser(r) ::= "this" + +NonLocalAttrRef(s) ::= "((Context)getInvokingContext())." +SetNonLocalAttr(s, rhsChunks) ::= + "((Context)getInvokingContext()). = ;" + +AddToLabelList(a) ::= "..add();" + +TokenDecl(t) ::= " " +TokenTypeDecl(t) ::= "int ;" +TokenListDecl(t) ::= "List\ = new ArrayList\()" +RuleContextDecl(r) ::= " " +RuleContextListDecl(rdecl) ::= "List\<> = new ArrayList\<>()" + +ContextTokenGetterDecl(t) ::= + "public TerminalNode () { return getToken(., 0); }" +ContextTokenListGetterDecl(t) ::= + "public List\ () { return getTokens(.); }" +ContextTokenListIndexedGetterDecl(t) ::= << +public TerminalNode (int i) { + return getToken(., i); +} +>> +ContextRuleGetterDecl(r) ::= << +public () { + return getRuleContext(.class,0); +} +>> +ContextRuleListGetterDecl(r) ::= << +public List\<\> () { + return getRuleContexts(.class); +} +>> +ContextRuleListIndexedGetterDecl(r) ::= << +public (int i) { + return getRuleContext(.class,i); +} +>> + +LexerRuleContext() ::= "RuleContext" + +/** The rule context name is the rule followed by a suffix; e.g., + * r becomes rContext. + */ +RuleContextNameSuffix() ::= "Context" + +ImplicitTokenLabel(tokenName) ::= "" +ImplicitRuleLabel(ruleName) ::= "" +ImplicitSetLabel(id) ::= "_tset" +ListLabelName(label) ::= "