From 801fe6583c1ed077a51b55fe44d94f429d1123ba Mon Sep 17 00:00:00 2001 From: "Thomas E. Enebo" Date: Thu, 27 Mar 2025 10:25:02 -0500 Subject: [PATCH 01/21] Update for 1.4.0 --- pom.xml | 15 +- .../jruby/prism/builder/IRBuilderPrism.java | 78 +- .../org/jruby/prism/parser/LoaderPrism.java | 4 + .../org/jruby/prism/parser/ParserPrism.java | 80 +- .../java/org/prism/AbstractNodeVisitor.java | 14 +- src/main/java/org/prism/Loader.java | 353 ++-- src/main/java/org/prism/Nodes.java | 1680 ++++++++++++----- src/main/java/org/prism/Parser.java | 1 + src/main/java/org/prism/ParsingOptions.java | 95 +- 9 files changed, 1591 insertions(+), 729 deletions(-) diff --git a/pom.xml b/pom.xml index a8ff204..7158f70 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ org.jruby jruby-prism jar - 0.30.0-SNAPSHOT + 1.4.0 jruby-prism Java portion of JRuby Prism parser support. @@ -12,6 +12,8 @@ UTF-8 + 21 + 21 @@ -50,7 +52,7 @@ org.jruby jruby-base - 9.4.6.0 + 10.0.0.0-SNAPSHOT junit @@ -72,15 +74,14 @@ maven-compiler-plugin - 3.8.0 - - 1.8 - 1.8 - + 3.14.0 default-compile + + -Xlint:unchecked + module-info.java diff --git a/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java b/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java index 280d769..1a39a7f 100644 --- a/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java +++ b/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java @@ -66,10 +66,11 @@ import org.prism.Nodes.*; import org.jruby.prism.parser.ParseResultPrism; -import java.math.BigDecimal; +import java.math.BigInteger; import java.util.ArrayList; import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Set; import static org.jruby.ir.instructions.RuntimeHelperCall.Methods.*; @@ -351,6 +352,8 @@ protected Operand build(Variable result, Node node) { return buildReturn((ReturnNode) node); } else if (node instanceof SelfNode) { return buildSelf(); + } else if (node instanceof ShareableConstantNode) { + return buildShareableConstant((ShareableConstantNode) node); } else if (node instanceof SingletonClassNode) { return buildSingletonClass((SingletonClassNode) node); } else if (node instanceof SourceEncodingNode) { @@ -568,7 +571,7 @@ private Operand buildBegin(BeginNode node) { RescueNode rescue = node.rescue_clause; Node ensureBody = node.ensure_clause != null ? node.ensure_clause.statements : null; return buildEnsureInternal(node.statements, node.else_clause, rescue.exceptions, rescue.statements, - rescue.consequent, false, ensureBody, true, rescue.reference); + rescue.subsequent, false, ensureBody, true, rescue.reference); } else if (node.ensure_clause != null) { EnsureNode ensure = node.ensure_clause; return buildEnsureInternal(node.statements, null, null, null, null, false, ensure.statements, false, null); @@ -820,11 +823,11 @@ private Operand buildCallOrWrite(CallOrWriteNode node) { } private Operand buildCase(CaseNode node) { - return buildCase(node.predicate, node.conditions, node.consequent); + return buildCase(node.predicate, node.conditions, node.else_clause); } private Operand buildCaseMatch(CaseMatchNode node) { - return buildPatternCase(node.predicate, node.conditions, node.consequent); + return buildPatternCase(node.predicate, node.conditions, node.else_clause); } private Operand buildClass(ClassNode node) { @@ -1397,7 +1400,7 @@ private Operand buildHash(Node[] elements, boolean hasAssignments) { } private Operand buildIf(Variable result, IfNode node) { - return buildConditional(result, node.predicate, node.statements, node.consequent); + return buildConditional(result, node.predicate, node.statements, node.subsequent); } private Operand buildIndexAndWrite(IndexAndWriteNode node) { @@ -1467,7 +1470,7 @@ protected Operand buildDRegex(Variable result, Node[] children, RegexpOptions op // value of the regexp. Adding an empty string will pick up the encoding from options (this // empty string is how legacy parsers do this but it naturally falls out of the parser. pieces = new Node[children.length + 1]; - pieces[0] = new StringNode((short) 0, EMPTY.bytes(), 0, 0); + pieces[0] = new StringNode(0, 0, (short) 0, EMPTY.bytes()); pieces[1] = children[0]; } else { pieces = children; @@ -1600,7 +1603,7 @@ private Operand buildMatchPredicate(MatchPredicateNode node) { } private Operand buildMatchRequired(MatchRequiredNode node) { - return buildPatternCase(node.value, new Node[] { new InNode(node.pattern, null, 0, 0) }, null); + return buildPatternCase(node.value, new Node[] { new InNode(0, 0, node.pattern, null) }, null); } private Operand buildMatchWrite(Variable result, MatchWriteNode node) { @@ -1805,19 +1808,15 @@ private Operand buildPreExecution(PreExecutionNode node) { } private Operand buildRational(RationalNode node) { - if (node.numeric instanceof FloatNode) { - BigDecimal bd = new BigDecimal(bytelistFrom(node.numeric).toString()); - BigDecimal denominator = BigDecimal.ONE.scaleByPowerOfTen(bd.scale()); - BigDecimal numerator = bd.multiply(denominator); - - try { - return new Rational(fix(numerator.longValueExact()), fix(denominator.longValueExact())); - } catch (ArithmeticException ae) { - return new Rational(new Bignum(numerator.toBigIntegerExact()), new Bignum(denominator.toBigIntegerExact())); - } - } + ImmutableLiteral num = asRationalValue(node.numerator); + ImmutableLiteral den = asRationalValue(node.denominator); + return new Rational(num, den); + } - return new Rational((ImmutableLiteral) build(node.numeric), fix(1)); + private ImmutableLiteral asRationalValue(Object value) { + return value instanceof Integer ? new Fixnum((int) value) : + value instanceof Long ? new Fixnum((long) value) : + new Bignum((BigInteger) value); } private Operand buildRange(RangeNode node) { @@ -1891,6 +1890,11 @@ private Operand buildRestKeywordArgs(KeywordHashNode keywordArgs, int[] flags) { return splatValue; } + private Operand buildShareableConstant(ShareableConstantNode node) { + // FIXME: We do not implement shareable constants yet + return build(node.write); + } + private Operand buildSingletonClass(SingletonClassNode node) { return buildSClass(node.expression, node.body, createStaticScopeFrom(node.locals, StaticScope.Type.LOCAL), getLine(node), getEndLine(node)); @@ -1945,7 +1949,7 @@ private Operand buildUndef(UndefNode node) { } private Operand buildUnless(Variable result, UnlessNode node) { - return buildConditional(result, node.predicate, node.consequent, node.statements); + return buildConditional(result, node.predicate, node.else_clause, node.statements); } private Operand buildUntil(UntilNode node) { @@ -1953,14 +1957,14 @@ private Operand buildUntil(UntilNode node) { } private void buildWhenSplatValues(Variable eqqResult, Node node, Operand testValue, Label bodyLabel, - Set seenLiterals) { + Set seenLiterals, Map origLocs) { // FIXME: could see errors since this is missing whatever is YARP args{cat,push}? if (node instanceof StatementsNode) { - buildWhenValues(eqqResult, ((StatementsNode) node).body, testValue, bodyLabel, seenLiterals); + buildWhenValues(eqqResult, ((StatementsNode) node).body, testValue, bodyLabel, seenLiterals, origLocs); } else if (node instanceof SplatNode) { - buildWhenValue(eqqResult, testValue, bodyLabel, node, seenLiterals, true); + buildWhenValue(eqqResult, testValue, bodyLabel, node, seenLiterals, origLocs, true); } else { - buildWhenValue(eqqResult, testValue, bodyLabel, node, seenLiterals, true); + buildWhenValue(eqqResult, testValue, bodyLabel, node, seenLiterals, origLocs, true); } } @@ -1992,7 +1996,7 @@ protected Node bodyFor(RescueNode node) { @Override protected RescueNode optRescueFor(RescueNode node) { - return node.consequent; + return node.subsequent; } // FIXME: Implement @@ -2228,19 +2232,20 @@ private Operand buildStatements(StatementsNode node) { } @Override - protected void buildWhenArgs(WhenNode whenNode, Operand testValue, Label bodyLabel, Set seenLiterals) { + protected void buildWhenArgs(WhenNode whenNode, Operand testValue, Label bodyLabel, + Set seenLiterals, Map origLocs) { Variable eqqResult = temp(); Node[] exprNodes = whenNode.conditions; if (exprNodes.length == 1) { if (exprNodes[0] instanceof SplatNode) { - buildWhenSplatValues(eqqResult, exprNodes[0], testValue, bodyLabel, seenLiterals); + buildWhenSplatValues(eqqResult, exprNodes[0], testValue, bodyLabel, seenLiterals, origLocs); } else { - buildWhenValue(eqqResult, testValue, bodyLabel, exprNodes[0], seenLiterals, false); + buildWhenValue(eqqResult, testValue, bodyLabel, exprNodes[0], seenLiterals, origLocs, false); } } else { for (Node value: exprNodes) { - buildWhenValue(eqqResult, testValue, bodyLabel, value, seenLiterals, value instanceof SplatNode); + buildWhenValue(eqqResult, testValue, bodyLabel, value, seenLiterals, origLocs, value instanceof SplatNode); } } } @@ -2428,10 +2433,10 @@ protected Variable buildPatternEach(Label testEnd, Variable result, Operand orig buildFindPattern(testEnd, result, deconstructed, node.constant, node.left, node.requireds, node.right, value, inAlternation, isSinglePattern, errorString); } else if (exprNodes instanceof IfNode) { IfNode node = (IfNode) exprNodes; - buildPatternEachIf(result, original, deconstructed, value, node.predicate, node.statements, node.consequent, inAlternation, isSinglePattern, errorString); + buildPatternEachIf(result, original, deconstructed, value, node.predicate, node.statements, node.subsequent, inAlternation, isSinglePattern, errorString); } else if (exprNodes instanceof UnlessNode) { UnlessNode node = (UnlessNode) exprNodes; - buildPatternEachIf(result, original, deconstructed, value, node.predicate, node.consequent, node.statements, inAlternation, isSinglePattern, errorString); + buildPatternEachIf(result, original, deconstructed, value, node.predicate, node.else_clause, node.statements, inAlternation, isSinglePattern, errorString); } else if (exprNodes instanceof LocalVariableTargetNode) { buildPatternLocal((LocalVariableTargetNode) exprNodes, value, inAlternation); } else if (exprNodes instanceof ImplicitNode) { @@ -2452,7 +2457,7 @@ protected Variable buildPatternEach(Label testEnd, Variable result, Operand orig Operand expression = build(exprNodes); boolean needsSplat = exprNodes instanceof AssocSplatNode; // FIXME: just a guess this is all we need for splat? - addInstr(new EQQInstr(scope, result, expression, value, needsSplat, scope.maybeUsingRefinements())); + addInstr(new EQQInstr(scope, result, expression, value, needsSplat, false, scope.maybeUsingRefinements())); } return result; @@ -2509,7 +2514,7 @@ protected void buildAssocs(Label testEnd, Operand original, Variable result, Has // FIXME: only build literals (which are guaranteed to build without raising). Operand key = build(((AssocNode) node).key); call(result, d, "key?", key); - cond_ne(testEnd, result, tru()); + cond_ne_true(testEnd, result); String method = hasRest ? "delete" : "[]"; Operand value = call(temp(), d, method, key); @@ -2528,7 +2533,7 @@ protected void buildAssocs(Label testEnd, Operand original, Variable result, Has buildPatternEach(testEnd, result, original, copy(nil()), value, ((AssocNode) node).value, inAlteration, isSinglePattern, errorString); } - cond_ne(testEnd, result, tru()); + cond_ne_true(testEnd, result); } } } @@ -2784,6 +2789,11 @@ protected Operand putConstant(ConstantPathNode path, Operand value) { return putConstant(buildModuleParent(path.parent), path.name, value); } + @Override + protected Operand putConstant(ConstantPathNode path, CodeBlock valueBuilder) { + return putConstant(buildModuleParent(path.parent), path.name, valueBuilder.run()); + } + protected RubySymbol symbol(SymbolNode node) { short flags = node.flags; Encoding encoding = SymbolFlags.isForcedUsAsciiEncoding(flags) ? USASCIIEncoding.INSTANCE : diff --git a/src/main/java/org/jruby/prism/parser/LoaderPrism.java b/src/main/java/org/jruby/prism/parser/LoaderPrism.java index ebae0f1..1843f47 100644 --- a/src/main/java/org/jruby/prism/parser/LoaderPrism.java +++ b/src/main/java/org/jruby/prism/parser/LoaderPrism.java @@ -7,6 +7,10 @@ import org.prism.Nodes; import org.prism.ParseResult; +/** + * Extends Loader to override some things which are not generated directly + * for JRuby. + */ public class LoaderPrism extends Loader { private Ruby runtime; diff --git a/src/main/java/org/jruby/prism/parser/ParserPrism.java b/src/main/java/org/jruby/prism/parser/ParserPrism.java index 3c209da..def8f7c 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrism.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrism.java @@ -6,14 +6,13 @@ import org.jruby.Ruby; import org.jruby.RubyArray; import org.jruby.RubyIO; +import org.jruby.RubyInstanceConfig; import org.jruby.RubySymbol; import org.jruby.ext.coverage.CoverageData; import org.jruby.management.ParserStats; import org.jruby.parser.Parser; -import org.jruby.parser.ParserManager; import org.jruby.parser.ParserType; import org.jruby.parser.StaticScope; -import org.jruby.runtime.Constants; import org.jruby.runtime.DynamicScope; import org.jruby.runtime.ThreadContext; import org.jruby.runtime.builtin.IRubyObject; @@ -38,6 +37,8 @@ import static org.jruby.parser.ParserType.MAIN; public class ParserPrism extends Parser { + private boolean parserTiming = org.jruby.util.cli.Options.PARSER_SUMMARY.load(); + private final ParserBindingPrism prismLibrary; public ParserPrism(Ruby runtime, ParserBindingPrism prismLibrary) { @@ -57,12 +58,12 @@ public ParseResult parse(String fileName, int lineNumber, ByteList content, Dyna private ParseResult parseInternal(String fileName, DynamicScope blockScope, byte[] source, byte[] serialized, ParserType type) { long time = 0; - if (ParserManager.PARSER_TIMING) time = System.nanoTime(); + if (parserTiming) time = System.nanoTime(); LoaderPrism loader = new LoaderPrism(runtime, serialized, source); org.prism.ParseResult res = loader.load(); Encoding encoding = loader.getEncoding(); - if (ParserManager.PARSER_TIMING) { + if (parserTiming) { ParserStats stats = runtime.getParserManager().getParserStats(); stats.addPrismTimeDeserializing(System.nanoTime() - time); @@ -72,7 +73,9 @@ private ParseResult parseInternal(String fileName, DynamicScope blockScope, byte if (res.warnings != null) { for (org.prism.ParseResult.Warning warning: res.warnings) { - runtime.getWarnings().warn(fileName, res.source.line(warning.location.startOffset), warning.message); + if (warning.level != org.prism.ParseResult.WarningLevel.WARNING_VERBOSE || runtime.isVerbose()) { + runtime.getWarnings().warn(fileName, res.source.line(warning.location.startOffset), warning.message); + } } } @@ -173,12 +176,12 @@ private byte[] parse(byte[] source, int sourceLength, byte[] metadata) { // if (ParserManager.PARSER_WASM) return parseChicory(source, sourceLength, metadata); long time = 0; - if (ParserManager.PARSER_TIMING) time = System.nanoTime(); + if (parserTiming) time = System.nanoTime(); ParserBindingPrism.Buffer buffer = new ParserBindingPrism.Buffer(jnr.ffi.Runtime.getRuntime(prismLibrary)); prismLibrary.pm_buffer_init(buffer); prismLibrary.pm_serialize_parse(buffer, source, sourceLength, metadata); - if (ParserManager.PARSER_TIMING) { + if (parserTiming) { ParserStats stats = runtime.getParserManager().getParserStats(); stats.addPrismTimeCParseSerialize(System.nanoTime() - time); @@ -194,11 +197,11 @@ private byte[] parse(byte[] source, int sourceLength, byte[] metadata) { /* private byte[] parseChicory(byte[] source, int sourceLength, byte[] metadata) { long time = 0; - if (ParserManager.PARSER_TIMING) time = System.nanoTime(); + if (parserTiming) time = System.nanoTime(); byte[] serialized = prismWasmWrapper.parse(source, sourceLength, metadata); - if (ParserManager.PARSER_TIMING) { + if (parserTiming) { ParserStats stats = runtime.getParserManager().getParserStats(); stats.addYARPTimeCParseSerialize(System.nanoTime() - time); @@ -226,14 +229,34 @@ private byte[] generateMetadata(String fileName, int lineNumber, Encoding encodi metadata.append(name); // frozen string literal - metadata.append(runtime.getInstanceConfig().isFrozenStringLiteral() ? 1 : 0); + Boolean frozen = runtime.getInstanceConfig().isFrozenStringLiteral(); + metadata.append(frozen != null && frozen ? 1 : 0); + + // command-line flags + RubyInstanceConfig config = runtime.getInstanceConfig(); + byte flags = 0; + if (config.isSplit()) flags |= 1; // -a + if (config.isInlineScript()) flags |= 2; // -e + if (config.isProcessLineEnds()) flags |= 4; // -l + //if (config.isAssumeLoop()) flags |= 8; // -n + //if (config.isAssumePrinting()) flags |= 16; // -p + if (config.isXFlag()) flags |= 32; // -x + metadata.append(flags); // version - if (Constants.RUBY_MAJOR_VERSION.equals("3.3")) { - metadata.append(ParsingOptions.SyntaxVersion.V3_3.getValue()); - } else { - metadata.append(ParsingOptions.SyntaxVersion.LATEST.getValue()); - } + metadata.append(ParsingOptions.SyntaxVersion.V3_4.getValue()); + + // Do not lock encoding + metadata.append(0); + + // main script + metadata.append(1); + + // partial script + metadata.append(0); + + // freeze + metadata.append(0); // Eval scopes (or none for normal parses) if (type == EVAL) { @@ -275,6 +298,7 @@ private int encodeEvalScopesInner(ByteList buf, StaticScope scope, int count) { // once more for method scope String names[] = scope.getVariables(); appendUnsignedInt(buf, names.length); + buf.append(0); for (String name : names) { // Get the bytes "raw" (which we use ISO8859_1 for) as this is how we record these in StaticScope. byte[] bytes = name.getBytes(ISO8859_1Encoding.INSTANCE.getCharset()); @@ -311,39 +335,39 @@ public ParseResult addGetsLoop(Ruby runtime, ParseResult result, boolean printin List newBody = new ArrayList<>(); if (processLineEndings) { - newBody.add(new Nodes.GlobalVariableWriteNode(runtime.newSymbol(CommonByteLists.DOLLAR_BACKSLASH), - new GlobalVariableReadNode(runtime.newSymbol(CommonByteLists.DOLLAR_SLASH), 0, 0), 0, 0)); + newBody.add(new Nodes.GlobalVariableWriteNode(0, 0, runtime.newSymbol(CommonByteLists.DOLLAR_BACKSLASH), + new GlobalVariableReadNode(0, 0, runtime.newSymbol(CommonByteLists.DOLLAR_SLASH)))); } - Nodes.GlobalVariableReadNode dollarUnderscore = new GlobalVariableReadNode(runtime.newSymbol(DOLLAR_UNDERSCORE), 0, 0); + Nodes.GlobalVariableReadNode dollarUnderscore = new GlobalVariableReadNode(0, 0, runtime.newSymbol(DOLLAR_UNDERSCORE)); List whileBody = new ArrayList<>(); if (processLineEndings) { - whileBody.add(new CallNode((short) 0, dollarUnderscore, runtime.newSymbol("chomp!"), null, null, 0, 0)); + whileBody.add(new CallNode(0, 0, (short) 0, dollarUnderscore, runtime.newSymbol("chomp!"), null, null)); } if (split) { - whileBody.add(new GlobalVariableWriteNode(runtime.newSymbol("$F"), - new Nodes.CallNode((short) 0, dollarUnderscore, runtime.newSymbol("split"), null, null, 0, 0), 0, 0)); + whileBody.add(new GlobalVariableWriteNode(0, 0, runtime.newSymbol("$F"), + new Nodes.CallNode(0, 0, (short) 0, dollarUnderscore, runtime.newSymbol("split"), null, null))); } StatementsNode stmts = ((ProgramNode) result.getAST()).statements; if (stmts != null && stmts.body != null) whileBody.addAll(Arrays.asList(stmts.body)); - ArgumentsNode args = new ArgumentsNode((short) 0, new Node[] { dollarUnderscore }, 0, 0); - if (printing) whileBody.add(new CallNode((short) 0, null, runtime.newSymbol("print"), args, null, 0, 0)); + ArgumentsNode args = new ArgumentsNode(0, 0, (short) 0, new Node[] { dollarUnderscore }); + if (printing) whileBody.add(new CallNode(0, 0, (short) 0, null, runtime.newSymbol("print"), args, null)); Node[] nodes = new Node[whileBody.size()]; whileBody.toArray(nodes); - StatementsNode statements = new StatementsNode(nodes, 0, 0); + StatementsNode statements = new StatementsNode(0, 0, nodes); - newBody.add(new WhileNode((short) 0, - new CallNode(CallNodeFlags.VARIABLE_CALL, null, runtime.newSymbol("gets"), null, null, 0, 0), - statements, 0, 0)); + newBody.add(new WhileNode(0, 0, (short) 0, + new CallNode(0, 0, CallNodeFlags.VARIABLE_CALL, null, runtime.newSymbol("gets"), null, null), + statements)); nodes = new Node[newBody.size()]; newBody.toArray(nodes); - Nodes.ProgramNode newRoot = new Nodes.ProgramNode(new RubySymbol[] {}, new StatementsNode(nodes, 0, 0), 0, 0); + Nodes.ProgramNode newRoot = new Nodes.ProgramNode(0, 0, new RubySymbol[] {}, new StatementsNode(0, 0, nodes)); ((ParseResultPrism) result).setRoot(newRoot); diff --git a/src/main/java/org/prism/AbstractNodeVisitor.java b/src/main/java/org/prism/AbstractNodeVisitor.java index 94941b9..bad1c32 100644 --- a/src/main/java/org/prism/AbstractNodeVisitor.java +++ b/src/main/java/org/prism/AbstractNodeVisitor.java @@ -1,10 +1,10 @@ -/******************************************************************************/ +/*----------------------------------------------------------------------------*/ /* This file is generated by the templates/template.rb script and should not */ /* be modified manually. See */ /* templates/java/org/prism/AbstractNodeVisitor.java.erb */ /* if you are looking to modify the */ /* template */ -/******************************************************************************/ +/*----------------------------------------------------------------------------*/ package org.prism; @@ -884,6 +884,16 @@ public T visitInterpolatedXStringNode(Nodes.InterpolatedXStringNode node) { return defaultVisit(node); } + /** + * Visit a ItLocalVariableReadNode node. + * + * @param node The node to visit. + * @return The result of visiting the node. + */ + public T visitItLocalVariableReadNode(Nodes.ItLocalVariableReadNode node) { + return defaultVisit(node); + } + /** * Visit a ItParametersNode node. * diff --git a/src/main/java/org/prism/Loader.java b/src/main/java/org/prism/Loader.java index c5bd596..eaadfa0 100644 --- a/src/main/java/org/prism/Loader.java +++ b/src/main/java/org/prism/Loader.java @@ -1,10 +1,10 @@ -/******************************************************************************/ +/*----------------------------------------------------------------------------*/ /* This file is generated by the templates/template.rb script and should not */ /* be modified manually. See */ /* templates/java/org/prism/Loader.java.erb */ /* if you are looking to modify the */ /* template */ -/******************************************************************************/ +/*----------------------------------------------------------------------------*/ package org.prism; @@ -100,8 +100,8 @@ protected ParseResult load() { expect((byte) 'S', "incorrect prism header"); expect((byte) 'M', "incorrect prism header"); - expect((byte) 0, "prism major version does not match"); - expect((byte) 29, "prism minor version does not match"); + expect((byte) 1, "prism major version does not match"); + expect((byte) 4, "prism minor version does not match"); expect((byte) 0, "prism patch version does not match"); expect((byte) 1, "Loader.java requires no location fields in the serialized output"); @@ -124,16 +124,21 @@ protected ParseResult load() { int constantPoolLength = loadVarUInt(); this.constantPool = new ConstantPool(this, source.bytes, constantPoolBufferOffset, constantPoolLength); - Nodes.Node node = loadNode(); + Nodes.Node node; + if (errors.length == 0) { + node = loadNode(); - int left = constantPoolBufferOffset - buffer.position(); - if (left != 0) { - throw new Error("Expected to consume all bytes while deserializing but there were " + left + " bytes left"); - } + int left = constantPoolBufferOffset - buffer.position(); + if (left != 0) { + throw new Error("Expected to consume all bytes while deserializing but there were " + left + " bytes left"); + } - boolean[] newlineMarked = new boolean[1 + source.getLineCount()]; - MarkNewlinesVisitor visitor = new MarkNewlinesVisitor(source, newlineMarked); - node.accept(visitor); + boolean[] newlineMarked = new boolean[1 + source.getLineCount()]; + MarkNewlinesVisitor visitor = new MarkNewlinesVisitor(source, newlineMarked); + node.accept(visitor); + } else { + node = null; + } return new ParseResult(node, magicComments, dataLocation, errors, warnings, source); } @@ -209,7 +214,7 @@ private ParseResult.Warning[] loadWarnings() { // warning messages only contain ASCII characters for (int i = 0; i < count; i++) { - Nodes.WarningType type = Nodes.WARNING_TYPES[loadVarUInt() - 273]; + Nodes.WarningType type = Nodes.WARNING_TYPES[loadVarUInt() - 289]; byte[] bytes = loadEmbeddedString(); String message = new String(bytes, StandardCharsets.US_ASCII); Nodes.Location location = loadLocation(); @@ -355,305 +360,307 @@ private Nodes.Node loadNode() { switch (type) { case 1: - return new Nodes.AliasGlobalVariableNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.AliasGlobalVariableNode(startOffset, length, loadNode(), loadNode()); case 2: - return new Nodes.AliasMethodNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.AliasMethodNode(startOffset, length, loadNode(), loadNode()); case 3: - return new Nodes.AlternationPatternNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.AlternationPatternNode(startOffset, length, loadNode(), loadNode()); case 4: - return new Nodes.AndNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.AndNode(startOffset, length, loadNode(), loadNode()); case 5: - return new Nodes.ArgumentsNode(loadFlags(), loadNodes(), startOffset, length); + return new Nodes.ArgumentsNode(startOffset, length, loadFlags(), loadNodes()); case 6: - return new Nodes.ArrayNode(loadFlags(), loadNodes(), startOffset, length); + return new Nodes.ArrayNode(startOffset, length, loadFlags(), loadNodes()); case 7: - return new Nodes.ArrayPatternNode(loadOptionalNode(), loadNodes(), loadOptionalNode(), loadNodes(), startOffset, length); + return new Nodes.ArrayPatternNode(startOffset, length, loadOptionalNode(), loadNodes(), loadOptionalNode(), loadNodes()); case 8: - return new Nodes.AssocNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.AssocNode(startOffset, length, loadNode(), loadNode()); case 9: - return new Nodes.AssocSplatNode(loadOptionalNode(), startOffset, length); + return new Nodes.AssocSplatNode(startOffset, length, loadOptionalNode()); case 10: - return new Nodes.BackReferenceReadNode(loadConstant(), startOffset, length); + return new Nodes.BackReferenceReadNode(startOffset, length, loadConstant()); case 11: - return new Nodes.BeginNode((Nodes.StatementsNode) loadOptionalNode(), (Nodes.RescueNode) loadOptionalNode(), (Nodes.ElseNode) loadOptionalNode(), (Nodes.EnsureNode) loadOptionalNode(), startOffset, length); + return new Nodes.BeginNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode(), (Nodes.RescueNode) loadOptionalNode(), (Nodes.ElseNode) loadOptionalNode(), (Nodes.EnsureNode) loadOptionalNode()); case 12: - return new Nodes.BlockArgumentNode(loadOptionalNode(), startOffset, length); + return new Nodes.BlockArgumentNode(startOffset, length, loadOptionalNode()); case 13: - return new Nodes.BlockLocalVariableNode(loadFlags(), loadConstant(), startOffset, length); + return new Nodes.BlockLocalVariableNode(startOffset, length, loadFlags(), loadConstant()); case 14: - return new Nodes.BlockNode(loadConstants(), loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.BlockNode(startOffset, length, loadConstants(), loadOptionalNode(), loadOptionalNode()); case 15: - return new Nodes.BlockParameterNode(loadFlags(), loadOptionalConstant(), startOffset, length); + return new Nodes.BlockParameterNode(startOffset, length, loadFlags(), loadOptionalConstant()); case 16: - return new Nodes.BlockParametersNode((Nodes.ParametersNode) loadOptionalNode(), loadBlockLocalVariableNodes(), startOffset, length); + return new Nodes.BlockParametersNode(startOffset, length, (Nodes.ParametersNode) loadOptionalNode(), loadBlockLocalVariableNodes()); case 17: - return new Nodes.BreakNode((Nodes.ArgumentsNode) loadOptionalNode(), startOffset, length); + return new Nodes.BreakNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); case 18: - return new Nodes.CallAndWriteNode(loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadNode(), startOffset, length); + return new Nodes.CallAndWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadNode()); case 19: - return new Nodes.CallNode(loadFlags(), loadOptionalNode(), loadConstant(), (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.CallNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode()); case 20: - return new Nodes.CallOperatorWriteNode(loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadConstant(), loadNode(), startOffset, length); + return new Nodes.CallOperatorWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadConstant(), loadNode()); case 21: - return new Nodes.CallOrWriteNode(loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadNode(), startOffset, length); + return new Nodes.CallOrWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadNode()); case 22: - return new Nodes.CallTargetNode(loadFlags(), loadNode(), loadConstant(), startOffset, length); + return new Nodes.CallTargetNode(startOffset, length, loadFlags(), loadNode(), loadConstant()); case 23: - return new Nodes.CapturePatternNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.CapturePatternNode(startOffset, length, loadNode(), (Nodes.LocalVariableTargetNode) loadNode()); case 24: - return new Nodes.CaseMatchNode(loadOptionalNode(), loadNodes(), (Nodes.ElseNode) loadOptionalNode(), startOffset, length); + return new Nodes.CaseMatchNode(startOffset, length, loadOptionalNode(), loadInNodes(), (Nodes.ElseNode) loadOptionalNode()); case 25: - return new Nodes.CaseNode(loadOptionalNode(), loadNodes(), (Nodes.ElseNode) loadOptionalNode(), startOffset, length); + return new Nodes.CaseNode(startOffset, length, loadOptionalNode(), loadWhenNodes(), (Nodes.ElseNode) loadOptionalNode()); case 26: - return new Nodes.ClassNode(loadConstants(), loadNode(), loadOptionalNode(), loadOptionalNode(), loadConstant(), startOffset, length); + return new Nodes.ClassNode(startOffset, length, loadConstants(), loadNode(), loadOptionalNode(), loadOptionalNode(), loadConstant()); case 27: - return new Nodes.ClassVariableAndWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.ClassVariableAndWriteNode(startOffset, length, loadConstant(), loadNode()); case 28: - return new Nodes.ClassVariableOperatorWriteNode(loadConstant(), loadNode(), loadConstant(), startOffset, length); + return new Nodes.ClassVariableOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); case 29: - return new Nodes.ClassVariableOrWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.ClassVariableOrWriteNode(startOffset, length, loadConstant(), loadNode()); case 30: - return new Nodes.ClassVariableReadNode(loadConstant(), startOffset, length); + return new Nodes.ClassVariableReadNode(startOffset, length, loadConstant()); case 31: - return new Nodes.ClassVariableTargetNode(loadConstant(), startOffset, length); + return new Nodes.ClassVariableTargetNode(startOffset, length, loadConstant()); case 32: - return new Nodes.ClassVariableWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.ClassVariableWriteNode(startOffset, length, loadConstant(), loadNode()); case 33: - return new Nodes.ConstantAndWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.ConstantAndWriteNode(startOffset, length, loadConstant(), loadNode()); case 34: - return new Nodes.ConstantOperatorWriteNode(loadConstant(), loadNode(), loadConstant(), startOffset, length); + return new Nodes.ConstantOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); case 35: - return new Nodes.ConstantOrWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.ConstantOrWriteNode(startOffset, length, loadConstant(), loadNode()); case 36: - return new Nodes.ConstantPathAndWriteNode((Nodes.ConstantPathNode) loadNode(), loadNode(), startOffset, length); + return new Nodes.ConstantPathAndWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode()); case 37: - return new Nodes.ConstantPathNode(loadOptionalNode(), loadOptionalConstant(), startOffset, length); + return new Nodes.ConstantPathNode(startOffset, length, loadOptionalNode(), loadOptionalConstant()); case 38: - return new Nodes.ConstantPathOperatorWriteNode((Nodes.ConstantPathNode) loadNode(), loadNode(), loadConstant(), startOffset, length); + return new Nodes.ConstantPathOperatorWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode(), loadConstant()); case 39: - return new Nodes.ConstantPathOrWriteNode((Nodes.ConstantPathNode) loadNode(), loadNode(), startOffset, length); + return new Nodes.ConstantPathOrWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode()); case 40: - return new Nodes.ConstantPathTargetNode(loadOptionalNode(), loadOptionalConstant(), startOffset, length); + return new Nodes.ConstantPathTargetNode(startOffset, length, loadOptionalNode(), loadOptionalConstant()); case 41: - return new Nodes.ConstantPathWriteNode((Nodes.ConstantPathNode) loadNode(), loadNode(), startOffset, length); + return new Nodes.ConstantPathWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode()); case 42: - return new Nodes.ConstantReadNode(loadConstant(), startOffset, length); + return new Nodes.ConstantReadNode(startOffset, length, loadConstant()); case 43: - return new Nodes.ConstantTargetNode(loadConstant(), startOffset, length); + return new Nodes.ConstantTargetNode(startOffset, length, loadConstant()); case 44: - return new Nodes.ConstantWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.ConstantWriteNode(startOffset, length, loadConstant(), loadNode()); case 45: - return new Nodes.DefNode(buffer.getInt(), loadConstant(), loadOptionalNode(), (Nodes.ParametersNode) loadOptionalNode(), loadOptionalNode(), loadConstants(), startOffset, length); + return new Nodes.DefNode(startOffset, length, buffer.getInt(), loadConstant(), loadOptionalNode(), (Nodes.ParametersNode) loadOptionalNode(), loadOptionalNode(), loadConstants()); case 46: - return new Nodes.DefinedNode(loadNode(), startOffset, length); + return new Nodes.DefinedNode(startOffset, length, loadNode()); case 47: - return new Nodes.ElseNode((Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.ElseNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); case 48: - return new Nodes.EmbeddedStatementsNode((Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.EmbeddedStatementsNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); case 49: - return new Nodes.EmbeddedVariableNode(loadNode(), startOffset, length); + return new Nodes.EmbeddedVariableNode(startOffset, length, loadNode()); case 50: - return new Nodes.EnsureNode((Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.EnsureNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); case 51: return new Nodes.FalseNode(startOffset, length); case 52: - return new Nodes.FindPatternNode(loadOptionalNode(), loadNode(), loadNodes(), loadNode(), startOffset, length); + return new Nodes.FindPatternNode(startOffset, length, loadOptionalNode(), (Nodes.SplatNode) loadNode(), loadNodes(), (Nodes.SplatNode) loadNode()); case 53: - return new Nodes.FlipFlopNode(loadFlags(), loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.FlipFlopNode(startOffset, length, loadFlags(), loadOptionalNode(), loadOptionalNode()); case 54: - return new Nodes.FloatNode(buffer.getDouble(), startOffset, length); + return new Nodes.FloatNode(startOffset, length, buffer.getDouble()); case 55: - return new Nodes.ForNode(loadNode(), loadNode(), (Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.ForNode(startOffset, length, loadNode(), loadNode(), (Nodes.StatementsNode) loadOptionalNode()); case 56: return new Nodes.ForwardingArgumentsNode(startOffset, length); case 57: return new Nodes.ForwardingParameterNode(startOffset, length); case 58: - return new Nodes.ForwardingSuperNode((Nodes.BlockNode) loadOptionalNode(), startOffset, length); + return new Nodes.ForwardingSuperNode(startOffset, length, (Nodes.BlockNode) loadOptionalNode()); case 59: - return new Nodes.GlobalVariableAndWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.GlobalVariableAndWriteNode(startOffset, length, loadConstant(), loadNode()); case 60: - return new Nodes.GlobalVariableOperatorWriteNode(loadConstant(), loadNode(), loadConstant(), startOffset, length); + return new Nodes.GlobalVariableOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); case 61: - return new Nodes.GlobalVariableOrWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.GlobalVariableOrWriteNode(startOffset, length, loadConstant(), loadNode()); case 62: - return new Nodes.GlobalVariableReadNode(loadConstant(), startOffset, length); + return new Nodes.GlobalVariableReadNode(startOffset, length, loadConstant()); case 63: - return new Nodes.GlobalVariableTargetNode(loadConstant(), startOffset, length); + return new Nodes.GlobalVariableTargetNode(startOffset, length, loadConstant()); case 64: - return new Nodes.GlobalVariableWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.GlobalVariableWriteNode(startOffset, length, loadConstant(), loadNode()); case 65: - return new Nodes.HashNode(loadNodes(), startOffset, length); + return new Nodes.HashNode(startOffset, length, loadNodes()); case 66: - return new Nodes.HashPatternNode(loadOptionalNode(), loadAssocNodes(), loadOptionalNode(), startOffset, length); + return new Nodes.HashPatternNode(startOffset, length, loadOptionalNode(), loadAssocNodes(), loadOptionalNode()); case 67: - return new Nodes.IfNode(loadNode(), (Nodes.StatementsNode) loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.IfNode(startOffset, length, loadNode(), (Nodes.StatementsNode) loadOptionalNode(), loadOptionalNode()); case 68: - return new Nodes.ImaginaryNode(loadNode(), startOffset, length); + return new Nodes.ImaginaryNode(startOffset, length, loadNode()); case 69: - return new Nodes.ImplicitNode(loadNode(), startOffset, length); + return new Nodes.ImplicitNode(startOffset, length, loadNode()); case 70: return new Nodes.ImplicitRestNode(startOffset, length); case 71: - return new Nodes.InNode(loadNode(), (Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.InNode(startOffset, length, loadNode(), (Nodes.StatementsNode) loadOptionalNode()); case 72: - return new Nodes.IndexAndWriteNode(loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode(), loadNode(), startOffset, length); + return new Nodes.IndexAndWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode(), loadNode()); case 73: - return new Nodes.IndexOperatorWriteNode(loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode(), loadConstant(), loadNode(), startOffset, length); + return new Nodes.IndexOperatorWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode(), loadConstant(), loadNode()); case 74: - return new Nodes.IndexOrWriteNode(loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode(), loadNode(), startOffset, length); + return new Nodes.IndexOrWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode(), loadNode()); case 75: - return new Nodes.IndexTargetNode(loadFlags(), loadNode(), (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.IndexTargetNode(startOffset, length, loadFlags(), loadNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode()); case 76: - return new Nodes.InstanceVariableAndWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.InstanceVariableAndWriteNode(startOffset, length, loadConstant(), loadNode()); case 77: - return new Nodes.InstanceVariableOperatorWriteNode(loadConstant(), loadNode(), loadConstant(), startOffset, length); + return new Nodes.InstanceVariableOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); case 78: - return new Nodes.InstanceVariableOrWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.InstanceVariableOrWriteNode(startOffset, length, loadConstant(), loadNode()); case 79: - return new Nodes.InstanceVariableReadNode(loadConstant(), startOffset, length); + return new Nodes.InstanceVariableReadNode(startOffset, length, loadConstant()); case 80: - return new Nodes.InstanceVariableTargetNode(loadConstant(), startOffset, length); + return new Nodes.InstanceVariableTargetNode(startOffset, length, loadConstant()); case 81: - return new Nodes.InstanceVariableWriteNode(loadConstant(), loadNode(), startOffset, length); + return new Nodes.InstanceVariableWriteNode(startOffset, length, loadConstant(), loadNode()); case 82: - return new Nodes.IntegerNode(loadFlags(), loadInteger(), startOffset, length); + return new Nodes.IntegerNode(startOffset, length, loadFlags(), loadInteger()); case 83: - return new Nodes.InterpolatedMatchLastLineNode(loadFlags(), loadNodes(), startOffset, length); + return new Nodes.InterpolatedMatchLastLineNode(startOffset, length, loadFlags(), loadNodes()); case 84: - return new Nodes.InterpolatedRegularExpressionNode(loadFlags(), loadNodes(), startOffset, length); + return new Nodes.InterpolatedRegularExpressionNode(startOffset, length, loadFlags(), loadNodes()); case 85: - return new Nodes.InterpolatedStringNode(loadFlags(), loadNodes(), startOffset, length); + return new Nodes.InterpolatedStringNode(startOffset, length, loadFlags(), loadNodes()); case 86: - return new Nodes.InterpolatedSymbolNode(loadNodes(), startOffset, length); + return new Nodes.InterpolatedSymbolNode(startOffset, length, loadNodes()); case 87: - return new Nodes.InterpolatedXStringNode(loadNodes(), startOffset, length); + return new Nodes.InterpolatedXStringNode(startOffset, length, loadNodes()); case 88: - return new Nodes.ItParametersNode(startOffset, length); + return new Nodes.ItLocalVariableReadNode(startOffset, length); case 89: - return new Nodes.KeywordHashNode(loadFlags(), loadNodes(), startOffset, length); + return new Nodes.ItParametersNode(startOffset, length); case 90: - return new Nodes.KeywordRestParameterNode(loadFlags(), loadOptionalConstant(), startOffset, length); + return new Nodes.KeywordHashNode(startOffset, length, loadFlags(), loadNodes()); case 91: - return new Nodes.LambdaNode(loadConstants(), loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.KeywordRestParameterNode(startOffset, length, loadFlags(), loadOptionalConstant()); case 92: - return new Nodes.LocalVariableAndWriteNode(loadNode(), loadConstant(), loadVarUInt(), startOffset, length); + return new Nodes.LambdaNode(startOffset, length, loadConstants(), loadOptionalNode(), loadOptionalNode()); case 93: - return new Nodes.LocalVariableOperatorWriteNode(loadNode(), loadConstant(), loadConstant(), loadVarUInt(), startOffset, length); + return new Nodes.LocalVariableAndWriteNode(startOffset, length, loadNode(), loadConstant(), loadVarUInt()); case 94: - return new Nodes.LocalVariableOrWriteNode(loadNode(), loadConstant(), loadVarUInt(), startOffset, length); + return new Nodes.LocalVariableOperatorWriteNode(startOffset, length, loadNode(), loadConstant(), loadConstant(), loadVarUInt()); case 95: - return new Nodes.LocalVariableReadNode(loadConstant(), loadVarUInt(), startOffset, length); + return new Nodes.LocalVariableOrWriteNode(startOffset, length, loadNode(), loadConstant(), loadVarUInt()); case 96: - return new Nodes.LocalVariableTargetNode(loadConstant(), loadVarUInt(), startOffset, length); + return new Nodes.LocalVariableReadNode(startOffset, length, loadConstant(), loadVarUInt()); case 97: - return new Nodes.LocalVariableWriteNode(loadConstant(), loadVarUInt(), loadNode(), startOffset, length); + return new Nodes.LocalVariableTargetNode(startOffset, length, loadConstant(), loadVarUInt()); case 98: - return new Nodes.MatchLastLineNode(loadFlags(), loadString(), startOffset, length); + return new Nodes.LocalVariableWriteNode(startOffset, length, loadConstant(), loadVarUInt(), loadNode()); case 99: - return new Nodes.MatchPredicateNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.MatchLastLineNode(startOffset, length, loadFlags(), loadString()); case 100: - return new Nodes.MatchRequiredNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.MatchPredicateNode(startOffset, length, loadNode(), loadNode()); case 101: - return new Nodes.MatchWriteNode((Nodes.CallNode) loadNode(), loadLocalVariableTargetNodes(), startOffset, length); + return new Nodes.MatchRequiredNode(startOffset, length, loadNode(), loadNode()); case 102: - return new Nodes.MissingNode(startOffset, length); + return new Nodes.MatchWriteNode(startOffset, length, (Nodes.CallNode) loadNode(), loadLocalVariableTargetNodes()); case 103: - return new Nodes.ModuleNode(loadConstants(), loadNode(), loadOptionalNode(), loadConstant(), startOffset, length); + return new Nodes.MissingNode(startOffset, length); case 104: - return new Nodes.MultiTargetNode(loadNodes(), loadOptionalNode(), loadNodes(), startOffset, length); + return new Nodes.ModuleNode(startOffset, length, loadConstants(), loadNode(), loadOptionalNode(), loadConstant()); case 105: - return new Nodes.MultiWriteNode(loadNodes(), loadOptionalNode(), loadNodes(), loadNode(), startOffset, length); + return new Nodes.MultiTargetNode(startOffset, length, loadNodes(), loadOptionalNode(), loadNodes()); case 106: - return new Nodes.NextNode((Nodes.ArgumentsNode) loadOptionalNode(), startOffset, length); + return new Nodes.MultiWriteNode(startOffset, length, loadNodes(), loadOptionalNode(), loadNodes(), loadNode()); case 107: - return new Nodes.NilNode(startOffset, length); + return new Nodes.NextNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); case 108: - return new Nodes.NoKeywordsParameterNode(startOffset, length); + return new Nodes.NilNode(startOffset, length); case 109: - return new Nodes.NumberedParametersNode(buffer.get(), startOffset, length); + return new Nodes.NoKeywordsParameterNode(startOffset, length); case 110: - return new Nodes.NumberedReferenceReadNode(loadVarUInt(), startOffset, length); + return new Nodes.NumberedParametersNode(startOffset, length, buffer.get()); case 111: - return new Nodes.OptionalKeywordParameterNode(loadFlags(), loadConstant(), loadNode(), startOffset, length); + return new Nodes.NumberedReferenceReadNode(startOffset, length, loadVarUInt()); case 112: - return new Nodes.OptionalParameterNode(loadFlags(), loadConstant(), loadNode(), startOffset, length); + return new Nodes.OptionalKeywordParameterNode(startOffset, length, loadFlags(), loadConstant(), loadNode()); case 113: - return new Nodes.OrNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.OptionalParameterNode(startOffset, length, loadFlags(), loadConstant(), loadNode()); case 114: - return new Nodes.ParametersNode(loadNodes(), loadOptionalParameterNodes(), loadOptionalNode(), loadNodes(), loadNodes(), loadOptionalNode(), (Nodes.BlockParameterNode) loadOptionalNode(), startOffset, length); + return new Nodes.OrNode(startOffset, length, loadNode(), loadNode()); case 115: - return new Nodes.ParenthesesNode(loadOptionalNode(), startOffset, length); + return new Nodes.ParametersNode(startOffset, length, loadNodes(), loadOptionalParameterNodes(), loadOptionalNode(), loadNodes(), loadNodes(), loadOptionalNode(), (Nodes.BlockParameterNode) loadOptionalNode()); case 116: - return new Nodes.PinnedExpressionNode(loadNode(), startOffset, length); + return new Nodes.ParenthesesNode(startOffset, length, loadFlags(), loadOptionalNode()); case 117: - return new Nodes.PinnedVariableNode(loadNode(), startOffset, length); + return new Nodes.PinnedExpressionNode(startOffset, length, loadNode()); case 118: - return new Nodes.PostExecutionNode((Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.PinnedVariableNode(startOffset, length, loadNode()); case 119: - return new Nodes.PreExecutionNode((Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.PostExecutionNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); case 120: - return new Nodes.ProgramNode(loadConstants(), (Nodes.StatementsNode) loadNode(), startOffset, length); + return new Nodes.PreExecutionNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); case 121: - return new Nodes.RangeNode(loadFlags(), loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.ProgramNode(startOffset, length, loadConstants(), (Nodes.StatementsNode) loadNode()); case 122: - return new Nodes.RationalNode(loadNode(), startOffset, length); + return new Nodes.RangeNode(startOffset, length, loadFlags(), loadOptionalNode(), loadOptionalNode()); case 123: - return new Nodes.RedoNode(startOffset, length); + return new Nodes.RationalNode(startOffset, length, loadFlags(), loadInteger(), loadInteger()); case 124: - return new Nodes.RegularExpressionNode(loadFlags(), loadString(), startOffset, length); + return new Nodes.RedoNode(startOffset, length); case 125: - return new Nodes.RequiredKeywordParameterNode(loadFlags(), loadConstant(), startOffset, length); + return new Nodes.RegularExpressionNode(startOffset, length, loadFlags(), loadString()); case 126: - return new Nodes.RequiredParameterNode(loadFlags(), loadConstant(), startOffset, length); + return new Nodes.RequiredKeywordParameterNode(startOffset, length, loadFlags(), loadConstant()); case 127: - return new Nodes.RescueModifierNode(loadNode(), loadNode(), startOffset, length); + return new Nodes.RequiredParameterNode(startOffset, length, loadFlags(), loadConstant()); case 128: - return new Nodes.RescueNode(loadNodes(), loadOptionalNode(), (Nodes.StatementsNode) loadOptionalNode(), (Nodes.RescueNode) loadOptionalNode(), startOffset, length); + return new Nodes.RescueModifierNode(startOffset, length, loadNode(), loadNode()); case 129: - return new Nodes.RestParameterNode(loadFlags(), loadOptionalConstant(), startOffset, length); + return new Nodes.RescueNode(startOffset, length, loadNodes(), loadOptionalNode(), (Nodes.StatementsNode) loadOptionalNode(), (Nodes.RescueNode) loadOptionalNode()); case 130: - return new Nodes.RetryNode(startOffset, length); + return new Nodes.RestParameterNode(startOffset, length, loadFlags(), loadOptionalConstant()); case 131: - return new Nodes.ReturnNode(loadFlags(), (Nodes.ArgumentsNode) loadOptionalNode(), startOffset, length); + return new Nodes.RetryNode(startOffset, length); case 132: - return new Nodes.SelfNode(startOffset, length); + return new Nodes.ReturnNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); case 133: - return new Nodes.ShareableConstantNode(loadFlags(), loadNode(), startOffset, length); + return new Nodes.SelfNode(startOffset, length); case 134: - return new Nodes.SingletonClassNode(loadConstants(), loadNode(), loadOptionalNode(), startOffset, length); + return new Nodes.ShareableConstantNode(startOffset, length, loadFlags(), loadNode()); case 135: - return new Nodes.SourceEncodingNode(startOffset, length); + return new Nodes.SingletonClassNode(startOffset, length, loadConstants(), loadNode(), loadOptionalNode()); case 136: - return new Nodes.SourceFileNode(loadFlags(), loadString(), startOffset, length); + return new Nodes.SourceEncodingNode(startOffset, length); case 137: - return new Nodes.SourceLineNode(startOffset, length); + return new Nodes.SourceFileNode(startOffset, length, loadFlags(), loadString()); case 138: - return new Nodes.SplatNode(loadOptionalNode(), startOffset, length); + return new Nodes.SourceLineNode(startOffset, length); case 139: - return new Nodes.StatementsNode(loadNodes(), startOffset, length); + return new Nodes.SplatNode(startOffset, length, loadOptionalNode()); case 140: - return new Nodes.StringNode(loadFlags(), loadString(), startOffset, length); + return new Nodes.StatementsNode(startOffset, length, loadNodes()); case 141: - return new Nodes.SuperNode((Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode(), startOffset, length); + return new Nodes.StringNode(startOffset, length, loadFlags(), loadString()); case 142: - return new Nodes.SymbolNode(loadFlags(), loadString(), startOffset, length); + return new Nodes.SuperNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode()); case 143: - return new Nodes.TrueNode(startOffset, length); + return new Nodes.SymbolNode(startOffset, length, loadFlags(), loadString()); case 144: - return new Nodes.UndefNode(loadNodes(), startOffset, length); + return new Nodes.TrueNode(startOffset, length); case 145: - return new Nodes.UnlessNode(loadNode(), (Nodes.StatementsNode) loadOptionalNode(), (Nodes.ElseNode) loadOptionalNode(), startOffset, length); + return new Nodes.UndefNode(startOffset, length, loadNodes()); case 146: - return new Nodes.UntilNode(loadFlags(), loadNode(), (Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.UnlessNode(startOffset, length, loadNode(), (Nodes.StatementsNode) loadOptionalNode(), (Nodes.ElseNode) loadOptionalNode()); case 147: - return new Nodes.WhenNode(loadNodes(), (Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.UntilNode(startOffset, length, loadFlags(), loadNode(), (Nodes.StatementsNode) loadOptionalNode()); case 148: - return new Nodes.WhileNode(loadFlags(), loadNode(), (Nodes.StatementsNode) loadOptionalNode(), startOffset, length); + return new Nodes.WhenNode(startOffset, length, loadNodes(), (Nodes.StatementsNode) loadOptionalNode()); case 149: - return new Nodes.XStringNode(loadFlags(), loadString(), startOffset, length); + return new Nodes.WhileNode(startOffset, length, loadFlags(), loadNode(), (Nodes.StatementsNode) loadOptionalNode()); case 150: - return new Nodes.YieldNode((Nodes.ArgumentsNode) loadOptionalNode(), startOffset, length); + return new Nodes.XStringNode(startOffset, length, loadFlags(), loadString()); + case 151: + return new Nodes.YieldNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); default: throw new Error("Unknown node type: " + type); } @@ -687,6 +694,34 @@ private Nodes.BlockLocalVariableNode[] loadBlockLocalVariableNodes() { return nodes; } + private static final Nodes.InNode[] EMPTY_InNode_ARRAY = {}; + + private Nodes.InNode[] loadInNodes() { + int length = loadVarUInt(); + if (length == 0) { + return EMPTY_InNode_ARRAY; + } + Nodes.InNode[] nodes = new Nodes.InNode[length]; + for (int i = 0; i < length; i++) { + nodes[i] = (Nodes.InNode) loadNode(); + } + return nodes; + } + + private static final Nodes.WhenNode[] EMPTY_WhenNode_ARRAY = {}; + + private Nodes.WhenNode[] loadWhenNodes() { + int length = loadVarUInt(); + if (length == 0) { + return EMPTY_WhenNode_ARRAY; + } + Nodes.WhenNode[] nodes = new Nodes.WhenNode[length]; + for (int i = 0; i < length; i++) { + nodes[i] = (Nodes.WhenNode) loadNode(); + } + return nodes; + } + private static final Nodes.AssocNode[] EMPTY_AssocNode_ARRAY = {}; private Nodes.AssocNode[] loadAssocNodes() { diff --git a/src/main/java/org/prism/Nodes.java b/src/main/java/org/prism/Nodes.java index 0a27329..2a28178 100644 --- a/src/main/java/org/prism/Nodes.java +++ b/src/main/java/org/prism/Nodes.java @@ -1,10 +1,10 @@ -/******************************************************************************/ +/*----------------------------------------------------------------------------*/ /* This file is generated by the templates/template.rb script and should not */ /* be modified manually. See */ /* templates/java/org/prism/Nodes.java.erb */ /* if you are looking to modify the */ /* template */ -/******************************************************************************/ +/*----------------------------------------------------------------------------*/ package org.prism; @@ -147,11 +147,24 @@ public String toString() { */ public static final class ArgumentsNodeFlags implements Comparable { - // if arguments contain keywords - public static final short CONTAINS_KEYWORDS = 1 << 0; + // if the arguments contain forwarding + public static final short CONTAINS_FORWARDING = 1 << 2; - // if arguments contain keyword splat - public static final short CONTAINS_KEYWORD_SPLAT = 1 << 1; + // if the arguments contain keywords + public static final short CONTAINS_KEYWORDS = 1 << 3; + + // if the arguments contain a keyword splat + public static final short CONTAINS_KEYWORD_SPLAT = 1 << 4; + + // if the arguments contain a splat + public static final short CONTAINS_SPLAT = 1 << 5; + + // if the arguments contain multiple splats + public static final short CONTAINS_MULTIPLE_SPLATS = 1 << 6; + + public static boolean isContainsForwarding(short flags) { + return (flags & CONTAINS_FORWARDING) != 0; + } public static boolean isContainsKeywords(short flags) { return (flags & CONTAINS_KEYWORDS) != 0; @@ -161,6 +174,14 @@ public static boolean isContainsKeywordSplat(short flags) { return (flags & CONTAINS_KEYWORD_SPLAT) != 0; } + public static boolean isContainsSplat(short flags) { + return (flags & CONTAINS_SPLAT) != 0; + } + + public static boolean isContainsMultipleSplats(short flags) { + return (flags & CONTAINS_MULTIPLE_SPLATS) != 0; + } + private final short flags; public ArgumentsNodeFlags(short flags) { @@ -186,6 +207,10 @@ public int compareTo(ArgumentsNodeFlags other) { return flags - other.flags; } + public boolean isContainsForwarding() { + return (flags & CONTAINS_FORWARDING) != 0; + } + public boolean isContainsKeywords() { return (flags & CONTAINS_KEYWORDS) != 0; } @@ -194,6 +219,14 @@ public boolean isContainsKeywordSplat() { return (flags & CONTAINS_KEYWORD_SPLAT) != 0; } + public boolean isContainsSplat() { + return (flags & CONTAINS_SPLAT) != 0; + } + + public boolean isContainsMultipleSplats() { + return (flags & CONTAINS_MULTIPLE_SPLATS) != 0; + } + } /** @@ -202,7 +235,7 @@ public boolean isContainsKeywordSplat() { public static final class ArrayNodeFlags implements Comparable { // if array contains splat nodes - public static final short CONTAINS_SPLAT = 1 << 0; + public static final short CONTAINS_SPLAT = 1 << 2; public static boolean isContainsSplat(short flags) { return (flags & CONTAINS_SPLAT) != 0; @@ -245,16 +278,16 @@ public boolean isContainsSplat() { public static final class CallNodeFlags implements Comparable { // &. operator - public static final short SAFE_NAVIGATION = 1 << 0; + public static final short SAFE_NAVIGATION = 1 << 2; // a call that could have been a local variable - public static final short VARIABLE_CALL = 1 << 1; + public static final short VARIABLE_CALL = 1 << 3; // a call that is an attribute write, so the value being written should be returned - public static final short ATTRIBUTE_WRITE = 1 << 2; + public static final short ATTRIBUTE_WRITE = 1 << 4; // a call that ignores method visibility - public static final short IGNORE_VISIBILITY = 1 << 3; + public static final short IGNORE_VISIBILITY = 1 << 5; public static boolean isSafeNavigation(short flags) { return (flags & SAFE_NAVIGATION) != 0; @@ -321,10 +354,10 @@ public boolean isIgnoreVisibility() { public static final class EncodingFlags implements Comparable { // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 0; + public static final short FORCED_UTF8_ENCODING = 1 << 2; // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 1; + public static final short FORCED_BINARY_ENCODING = 1 << 3; public static boolean isForcedUtf8Encoding(short flags) { return (flags & FORCED_UTF8_ENCODING) != 0; @@ -375,16 +408,16 @@ public boolean isForcedBinaryEncoding() { public static final class IntegerBaseFlags implements Comparable { // 0b prefix - public static final short BINARY = 1 << 0; + public static final short BINARY = 1 << 2; // 0d or no prefix - public static final short DECIMAL = 1 << 1; + public static final short DECIMAL = 1 << 3; // 0o or 0 prefix - public static final short OCTAL = 1 << 2; + public static final short OCTAL = 1 << 4; // 0x prefix - public static final short HEXADECIMAL = 1 << 3; + public static final short HEXADECIMAL = 1 << 5; public static boolean isBinary(short flags) { return (flags & BINARY) != 0; @@ -451,10 +484,10 @@ public boolean isHexadecimal() { public static final class InterpolatedStringNodeFlags implements Comparable { // frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - public static final short FROZEN = 1 << 0; + public static final short FROZEN = 1 << 2; // mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - public static final short MUTABLE = 1 << 1; + public static final short MUTABLE = 1 << 3; public static boolean isFrozen(short flags) { return (flags & FROZEN) != 0; @@ -505,7 +538,7 @@ public boolean isMutable() { public static final class KeywordHashNodeFlags implements Comparable { // a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments - public static final short SYMBOL_KEYS = 1 << 0; + public static final short SYMBOL_KEYS = 1 << 2; public static boolean isSymbolKeys(short flags) { return (flags & SYMBOL_KEYS) != 0; @@ -548,7 +581,7 @@ public boolean isSymbolKeys() { public static final class LoopFlags implements Comparable { // a loop after a begin statement, so the body is executed first before the condition - public static final short BEGIN_MODIFIER = 1 << 0; + public static final short BEGIN_MODIFIER = 1 << 2; public static boolean isBeginModifier(short flags) { return (flags & BEGIN_MODIFIER) != 0; @@ -591,7 +624,7 @@ public boolean isBeginModifier() { public static final class ParameterFlags implements Comparable { // a parameter name that has been repeated in the method signature - public static final short REPEATED_PARAMETER = 1 << 0; + public static final short REPEATED_PARAMETER = 1 << 2; public static boolean isRepeatedParameter(short flags) { return (flags & REPEATED_PARAMETER) != 0; @@ -628,13 +661,56 @@ public boolean isRepeatedParameter() { } + /** + * Flags for parentheses nodes. + */ + public static final class ParenthesesNodeFlags implements Comparable { + + // parentheses that contain multiple potentially void statements + public static final short MULTIPLE_STATEMENTS = 1 << 2; + + public static boolean isMultipleStatements(short flags) { + return (flags & MULTIPLE_STATEMENTS) != 0; + } + + private final short flags; + + public ParenthesesNodeFlags(short flags) { + this.flags = flags; + } + + @Override + public int hashCode() { + return flags; + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof ParenthesesNodeFlags)) { + return false; + } + + return flags == ((ParenthesesNodeFlags) other).flags; + } + + @Override + public int compareTo(ParenthesesNodeFlags other) { + return flags - other.flags; + } + + public boolean isMultipleStatements() { + return (flags & MULTIPLE_STATEMENTS) != 0; + } + + } + /** * Flags for range and flip-flop nodes. */ public static final class RangeFlags implements Comparable { // ... operator - public static final short EXCLUDE_END = 1 << 0; + public static final short EXCLUDE_END = 1 << 2; public static boolean isExcludeEnd(short flags) { return (flags & EXCLUDE_END) != 0; @@ -677,37 +753,37 @@ public boolean isExcludeEnd() { public static final class RegularExpressionFlags implements Comparable { // i - ignores the case of characters when matching - public static final short IGNORE_CASE = 1 << 0; + public static final short IGNORE_CASE = 1 << 2; // x - ignores whitespace and allows comments in regular expressions - public static final short EXTENDED = 1 << 1; + public static final short EXTENDED = 1 << 3; // m - allows $ to match the end of lines within strings - public static final short MULTI_LINE = 1 << 2; + public static final short MULTI_LINE = 1 << 4; // o - only interpolates values into the regular expression once - public static final short ONCE = 1 << 3; + public static final short ONCE = 1 << 5; // e - forces the EUC-JP encoding - public static final short EUC_JP = 1 << 4; + public static final short EUC_JP = 1 << 6; // n - forces the ASCII-8BIT encoding - public static final short ASCII_8BIT = 1 << 5; + public static final short ASCII_8BIT = 1 << 7; // s - forces the Windows-31J encoding - public static final short WINDOWS_31J = 1 << 6; + public static final short WINDOWS_31J = 1 << 8; // u - forces the UTF-8 encoding - public static final short UTF_8 = 1 << 7; + public static final short UTF_8 = 1 << 9; // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 8; + public static final short FORCED_UTF8_ENCODING = 1 << 10; // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 9; + public static final short FORCED_BINARY_ENCODING = 1 << 11; // internal bytes forced the encoding to US-ASCII - public static final short FORCED_US_ASCII_ENCODING = 1 << 10; + public static final short FORCED_US_ASCII_ENCODING = 1 << 12; public static boolean isIgnoreCase(short flags) { return (flags & IGNORE_CASE) != 0; @@ -824,62 +900,19 @@ public boolean isForcedUsAsciiEncoding() { } - /** - * Flags for return nodes. - */ - public static final class ReturnNodeFlags implements Comparable { - - // a return statement that is redundant because it is the last statement in a method - public static final short REDUNDANT = 1 << 0; - - public static boolean isRedundant(short flags) { - return (flags & REDUNDANT) != 0; - } - - private final short flags; - - public ReturnNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof ReturnNodeFlags)) { - return false; - } - - return flags == ((ReturnNodeFlags) other).flags; - } - - @Override - public int compareTo(ReturnNodeFlags other) { - return flags - other.flags; - } - - public boolean isRedundant() { - return (flags & REDUNDANT) != 0; - } - - } - /** * Flags for shareable constant nodes. */ public static final class ShareableConstantNodeFlags implements Comparable { // constant writes that should be modified with shareable constant value literal - public static final short LITERAL = 1 << 0; + public static final short LITERAL = 1 << 2; // constant writes that should be modified with shareable constant value experimental everything - public static final short EXPERIMENTAL_EVERYTHING = 1 << 1; + public static final short EXPERIMENTAL_EVERYTHING = 1 << 3; // constant writes that should be modified with shareable constant value experimental copy - public static final short EXPERIMENTAL_COPY = 1 << 2; + public static final short EXPERIMENTAL_COPY = 1 << 4; public static boolean isLiteral(short flags) { return (flags & LITERAL) != 0; @@ -938,16 +971,16 @@ public boolean isExperimentalCopy() { public static final class StringFlags implements Comparable { // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 0; + public static final short FORCED_UTF8_ENCODING = 1 << 2; // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 1; + public static final short FORCED_BINARY_ENCODING = 1 << 3; // frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal` - public static final short FROZEN = 1 << 2; + public static final short FROZEN = 1 << 4; // mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` - public static final short MUTABLE = 1 << 3; + public static final short MUTABLE = 1 << 5; public static boolean isForcedUtf8Encoding(short flags) { return (flags & FORCED_UTF8_ENCODING) != 0; @@ -1014,13 +1047,13 @@ public boolean isMutable() { public static final class SymbolFlags implements Comparable { // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 0; + public static final short FORCED_UTF8_ENCODING = 1 << 2; // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 1; + public static final short FORCED_BINARY_ENCODING = 1 << 3; // internal bytes forced the encoding to US-ASCII - public static final short FORCED_US_ASCII_ENCODING = 1 << 2; + public static final short FORCED_US_ASCII_ENCODING = 1 << 4; public static boolean isForcedUtf8Encoding(short flags) { return (flags & FORCED_UTF8_ENCODING) != 0; @@ -1084,24 +1117,26 @@ public boolean isForcedUsAsciiEncoding() { public static final class AliasGlobalVariableNode extends Node { /** * 
-         * Represents the new name of the global variable that can be used after aliasing. This can be either a global variable, a back reference, or a numbered reference.
+         * Represents the new name of the global variable that can be used after aliasing.
          *
          *     alias $foo $bar
          *           ^^^^
          *
*/ + @UnionType({ GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class }) public final Node new_name; /** * 
-         * Represents the old name of the global variable that could be used before aliasing. This can be either a global variable, a back reference, or a numbered reference.
+         * Represents the old name of the global variable that can be used before aliasing.
          *
          *     alias $foo $bar
          *                ^^^^
          *
*/ + @UnionType({ GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class }) public final Node old_name; - public AliasGlobalVariableNode(Node new_name, Node old_name, int startOffset, int length) { + public AliasGlobalVariableNode(int startOffset, int length, Node new_name, Node old_name) { super(startOffset, length); this.new_name = new_name; this.old_name = old_name; @@ -1148,10 +1183,40 @@ protected String toString(String indent) { * */ public static final class AliasMethodNode extends Node { + /** + * 
+         * Represents the new name of the method that will be aliased.
+         *
+         *     alias foo bar
+         *           ^^^
+         *
+         *     alias :foo :bar
+         *           ^^^^
+         *
+         *     alias :"#{foo}" :"#{bar}"
+         *           ^^^^^^^^^
+         *
+ */ + @UnionType({ SymbolNode.class, InterpolatedSymbolNode.class }) public final Node new_name; + /** + * 
+         * Represents the old name of the method that will be aliased.
+         *
+         *     alias foo bar
+         *               ^^^
+         *
+         *     alias :foo :bar
+         *                ^^^^
+         *
+         *     alias :"#{foo}" :"#{bar}"
+         *                     ^^^^^^^^^
+         *
+ */ + @UnionType({ SymbolNode.class, InterpolatedSymbolNode.class }) public final Node old_name; - public AliasMethodNode(Node new_name, Node old_name, int startOffset, int length) { + public AliasMethodNode(int startOffset, int length, Node new_name, Node old_name) { super(startOffset, length); this.new_name = new_name; this.old_name = old_name; @@ -1198,10 +1263,26 @@ protected String toString(String indent) { * */ public static final class AlternationPatternNode extends Node { + /** + * 
+         * Represents the left side of the expression.
+         *
+         *     foo => bar | baz
+         *            ^^^
+         *
+ */ public final Node left; + /** + * 
+         * Represents the right side of the expression.
+         *
+         *     foo => bar | baz
+         *                  ^^^
+         *
+ */ public final Node right; - public AlternationPatternNode(Node left, Node right, int startOffset, int length) { + public AlternationPatternNode(int startOffset, int length, Node left, Node right) { super(startOffset, length); this.left = left; this.right = right; @@ -1262,7 +1343,7 @@ public static final class AndNode extends Node { public final Node left; /** * 
-         * Represents the right side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         * Represents the right side of the expression.
          *
          *     left && right
          *             ^^^^^
@@ -1273,7 +1354,7 @@ public static final class AndNode extends Node {
          */
         public final Node right;
 
-        public AndNode(Node left, Node right, int startOffset, int length) {
+        public AndNode(int startOffset, int length, Node left, Node right) {
             super(startOffset, length);
             this.left = left;
             this.right = right;
@@ -1321,20 +1402,40 @@ protected String toString(String indent) {
      */
     public static final class ArgumentsNode extends Node {
         public final short flags;
+        /**
+         * 
+         * The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     foo(bar, baz)
+         *         ^^^^^^^^
+         * 

+         */
         public final Node[] arguments;
 
-        public ArgumentsNode(short flags, Node[] arguments, int startOffset, int length) {
+        public ArgumentsNode(int startOffset, int length, short flags, Node[] arguments) {
             super(startOffset, length);
             this.flags = flags;
             this.arguments = arguments;
         }
         
+        public boolean isContainsForwarding() {
+            return ArgumentsNodeFlags.isContainsForwarding(flags);
+        }
+
         public boolean isContainsKeywords() {
-            return ArgumentsNodeFlags.isContainsKeywords(this.flags);
+            return ArgumentsNodeFlags.isContainsKeywords(flags);
         }
 
         public boolean isContainsKeywordSplat() {
-            return ArgumentsNodeFlags.isContainsKeywordSplat(this.flags);
+            return ArgumentsNodeFlags.isContainsKeywordSplat(flags);
+        }
+
+        public boolean isContainsSplat() {
+            return ArgumentsNodeFlags.isContainsSplat(flags);
+        }
+
+        public boolean isContainsMultipleSplats() {
+            return ArgumentsNodeFlags.isContainsMultipleSplats(flags);
         }
         
         public  void visitChildNodes(AbstractNodeVisitor visitor) {
@@ -1364,8 +1465,8 @@ protected String toString(String indent) {
             String nextIndent = indent + "  ";
             String nextNextIndent = nextIndent + "  ";
             builder.append(nextIndent);
-            builder.append("flags: ");
-            builder.append(this.flags);
+            builder.append("ArgumentsNodeFlags: ");
+            builder.append(flags);
             builder.append('\n');
             builder.append(nextIndent);
             builder.append("arguments: ");
@@ -1394,14 +1495,14 @@ public static final class ArrayNode extends Node {
          */
         public final Node[] elements;
 
-        public ArrayNode(short flags, Node[] elements, int startOffset, int length) {
+        public ArrayNode(int startOffset, int length, short flags, Node[] elements) {
             super(startOffset, length);
             this.flags = flags;
             this.elements = elements;
         }
         
         public boolean isContainsSplat() {
-            return ArrayNodeFlags.isContainsSplat(this.flags);
+            return ArrayNodeFlags.isContainsSplat(flags);
         }
         
         public  void visitChildNodes(AbstractNodeVisitor visitor) {
@@ -1431,8 +1532,8 @@ protected String toString(String indent) {
             String nextIndent = indent + "  ";
             String nextNextIndent = nextIndent + "  ";
             builder.append(nextIndent);
-            builder.append("flags: ");
-            builder.append(this.flags);
+            builder.append("ArrayNodeFlags: ");
+            builder.append(flags);
             builder.append('\n');
             builder.append(nextIndent);
             builder.append("elements: ");
@@ -1454,8 +1555,8 @@ protected String toString(String indent) {
      *     foo in [1, 2]
      *     ^^^^^^^^^^^^^
      *
-     *     foo in *1
-     *     ^^^^^^^^^
+     *     foo in *bar
+     *     ^^^^^^^^^^^
      *
      *     foo in Bar[]
      *     ^^^^^^^^^^^^
@@ -1466,13 +1567,38 @@ protected String toString(String indent) {
      */
     public static final class ArrayPatternNode extends Node {
         @Nullable
+        @UnionType({ ConstantReadNode.class, ConstantPathNode.class })
         public final Node constant;
+        /**
+         * 
+         * Represents the required elements of the array pattern.
+         *
+         *     foo in [1, 2]
+         *             ^  ^
+         * 

+         */
         public final Node[] requireds;
+        /**
+         * 
+         * Represents the rest element of the array pattern.
+         *
+         *     foo in *bar
+         *            ^^^^
+         * 

+         */
         @Nullable
         public final Node rest;
+        /**
+         * 
+         * Represents the elements after the rest element of the array pattern.
+         *
+         *     foo in *bar, baz
+         *                  ^^^
+         * 

+         */
         public final Node[] posts;
 
-        public ArrayPatternNode(Node constant, Node[] requireds, Node rest, Node[] posts, int startOffset, int length) {
+        public ArrayPatternNode(int startOffset, int length, Node constant, Node[] requireds, Node rest, Node[] posts) {
             super(startOffset, length);
             this.constant = constant;
             this.requireds = requireds;
@@ -1577,7 +1703,7 @@ public static final class AssocNode extends Node {
          */
         public final Node value;
 
-        public AssocNode(Node key, Node value, int startOffset, int length) {
+        public AssocNode(int startOffset, int length, Node key, Node value) {
             super(startOffset, length);
             this.key = key;
             this.value = value;
@@ -1635,7 +1761,7 @@ public static final class AssocSplatNode extends Node {
         @Nullable
         public final Node value;
 
-        public AssocSplatNode(Node value, int startOffset, int length) {
+        public AssocSplatNode(int startOffset, int length, Node value) {
             super(startOffset, length);
             this.value = value;
         }
@@ -1690,7 +1816,7 @@ public static final class BackReferenceReadNode extends Node {
          */
         public final org.jruby.RubySymbol name;
 
-        public BackReferenceReadNode(org.jruby.RubySymbol name, int startOffset, int length) {
+        public BackReferenceReadNode(int startOffset, int length, org.jruby.RubySymbol name) {
             super(startOffset, length);
             this.name = name;
         }
@@ -1734,16 +1860,48 @@ protected String toString(String indent) {
      *
*/ public static final class BeginNode extends Node { + /** + * 
+         * Represents the statements within the begin block.
+         *
+         *     begin x end
+         *           ^
+         *
+ */ @Nullable public final StatementsNode statements; + /** + * 
+         * Represents the rescue clause within the begin block.
+         *
+         *     begin x; rescue y; end
+         *              ^^^^^^^^
+         *
+ */ @Nullable public final RescueNode rescue_clause; + /** + * 
+         * Represents the else clause within the begin block.
+         *
+         *     begin x; rescue y; else z; end
+         *                        ^^^^^^
+         *
+ */ @Nullable public final ElseNode else_clause; + /** + * 
+         * Represents the ensure clause within the begin block.
+         *
+         *     begin x; ensure y; end
+         *              ^^^^^^^^
+         *
+ */ @Nullable public final EnsureNode ensure_clause; - public BeginNode(StatementsNode statements, RescueNode rescue_clause, ElseNode else_clause, EnsureNode ensure_clause, int startOffset, int length) { + public BeginNode(int startOffset, int length, StatementsNode statements, RescueNode rescue_clause, ElseNode else_clause, EnsureNode ensure_clause) { super(startOffset, length); this.statements = statements; this.rescue_clause = rescue_clause; @@ -1806,17 +1964,25 @@ protected String toString(String indent) { /** * 
-     * Represents block method arguments.
+     * Represents a block argument using `&`.
      *
      *     bar(&args)
      *     ^^^^^^^^^^
      *
*/ public static final class BlockArgumentNode extends Node { + /** + * 
+         * The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     foo(&args)
+         *         ^^^^^
+         *
+ */ @Nullable public final Node expression; - public BlockArgumentNode(Node expression, int startOffset, int length) { + public BlockArgumentNode(int startOffset, int length, Node expression) { super(startOffset, length); this.expression = expression; } @@ -1861,16 +2027,24 @@ protected String toString(String indent) { */ public static final class BlockLocalVariableNode extends Node { public final short flags; + /** + * 
+         * The name of the block local variable.
+         *
+         *     a { |; b| } # name `:b`
+         *            ^
+         *
+ */ public final org.jruby.RubySymbol name; - public BlockLocalVariableNode(short flags, org.jruby.RubySymbol name, int startOffset, int length) { + public BlockLocalVariableNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { super(startOffset, length); this.flags = flags; this.name = name; } public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(this.flags); + return ParameterFlags.isRepeatedParameter(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -1894,8 +2068,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("ParameterFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("name: "); @@ -1914,13 +2088,43 @@ protected String toString(String indent) { * */ public static final class BlockNode extends Node { + /** + * 
+         * The local variables declared in the block.
+         *
+         *     [1, 2, 3].each { |i| puts x } # locals: [:i]
+         *                       ^
+         *
+ */ public final org.jruby.RubySymbol[] locals; + /** + * 
+         * The parameters of the block.
+         *
+         *     [1, 2, 3].each { |i| puts x }
+         *                      ^^^
+         *     [1, 2, 3].each { puts _1 }
+         *                    ^^^^^^^^^^^
+         *     [1, 2, 3].each { puts it }
+         *                    ^^^^^^^^^^^
+         *
+ */ @Nullable + @UnionType({ BlockParametersNode.class, NumberedParametersNode.class, ItParametersNode.class }) public final Node parameters; + /** + * 
+         * The body of the block.
+         *
+         *     [1, 2, 3].each { |i| puts x }
+         *                          ^^^^^^
+         *
+ */ @Nullable + @UnionType({ StatementsNode.class, BeginNode.class }) public final Node body; - public BlockNode(org.jruby.RubySymbol[] locals, Node parameters, Node body, int startOffset, int length) { + public BlockNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node parameters, Node body) { super(startOffset, length); this.locals = locals; this.parameters = parameters; @@ -1972,7 +2176,7 @@ protected String toString(String indent) { /** * 
-     * Represents a block parameter to a method, block, or lambda definition.
+     * Represents a block parameter of a method, block, or lambda definition.
      *
      *     def a(&b)
      *           ^^
@@ -1981,17 +2185,26 @@ protected String toString(String indent) {
      */
     public static final class BlockParameterNode extends Node {
         public final short flags;
+        /**
+         * 
+         * The name of the block parameter.
+         *
+         *     def a(&b) # name `:b`
+         *            ^
+         *     end
+         * 

+         */
         @Nullable
         public final org.jruby.RubySymbol name;
 
-        public BlockParameterNode(short flags, org.jruby.RubySymbol name, int startOffset, int length) {
+        public BlockParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) {
             super(startOffset, length);
             this.flags = flags;
             this.name = name;
         }
         
         public boolean isRepeatedParameter() {
-            return ParameterFlags.isRepeatedParameter(this.flags);
+            return ParameterFlags.isRepeatedParameter(flags);
         }
         
         public  void visitChildNodes(AbstractNodeVisitor visitor) {
@@ -2015,8 +2228,8 @@ protected String toString(String indent) {
             builder.append('\n');
             String nextIndent = indent + "  ";
             builder.append(nextIndent);
-            builder.append("flags: ");
-            builder.append(this.flags);
+            builder.append("ParameterFlags: ");
+            builder.append(flags);
             builder.append('\n');
             builder.append(nextIndent);
             builder.append("name: ");
@@ -2039,11 +2252,35 @@ protected String toString(String indent) {
      *
*/ public static final class BlockParametersNode extends Node { + /** + * 
+         * Represents the parameters of the block.
+         *
+         *     -> (a, b = 1; local) { }
+         *         ^^^^^^^^
+         *
+         *     foo do |a, b = 1; local|
+         *             ^^^^^^^^
+         *     end
+         *
+ */ @Nullable public final ParametersNode parameters; + /** + * 
+         * Represents the local variables of the block.
+         *
+         *     -> (a, b = 1; local) { }
+         *                   ^^^^^
+         *
+         *     foo do |a, b = 1; local|
+         *                       ^^^^^
+         *     end
+         *
+ */ public final BlockLocalVariableNode[] locals; - public BlockParametersNode(ParametersNode parameters, BlockLocalVariableNode[] locals, int startOffset, int length) { + public BlockParametersNode(int startOffset, int length, ParametersNode parameters, BlockLocalVariableNode[] locals) { super(startOffset, length); this.parameters = parameters; this.locals = locals; @@ -2112,7 +2349,7 @@ public static final class BreakNode extends Node { @Nullable public final ArgumentsNode arguments; - public BreakNode(ArgumentsNode arguments, int startOffset, int length) { + public BreakNode(int startOffset, int length, ArgumentsNode arguments) { super(startOffset, length); this.arguments = arguments; } @@ -2157,13 +2394,45 @@ protected String toString(String indent) { */ public static final class CallAndWriteNode extends Node { public final short flags; + /** + * 
+         * The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     foo.bar &&= value
+         *     ^^^
+         *
+ */ @Nullable public final Node receiver; + /** + * 
+         * Represents the name of the method being called.
+         *
+         *     foo.bar &&= value # read_name `:bar`
+         *         ^^^
+         *
+ */ public final org.jruby.RubySymbol read_name; + /** + * 
+         * Represents the name of the method being written to.
+         *
+         *     foo.bar &&= value # write_name `:bar=`
+         *         ^^^
+         *
+ */ public final org.jruby.RubySymbol write_name; + /** + * 
+         * Represents the value being assigned.
+         *
+         *     foo.bar &&= value
+         *                 ^^^^^
+         *
+ */ public final Node value; - public CallAndWriteNode(short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, Node value, int startOffset, int length) { + public CallAndWriteNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, Node value) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -2173,19 +2442,19 @@ public CallAndWriteNode(short flags, Node receiver, org.jruby.RubySymbol read_na } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -2213,8 +2482,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -2275,13 +2544,38 @@ public static final class CallNode extends Node { */ @Nullable public final Node receiver; + /** + * 
+         * Represents the name of the method being called.
+         *
+         *     foo.bar # name `:foo`
+         *     ^^^
+         *
+ */ public final org.jruby.RubySymbol name; + /** + * 
+         * Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     foo(bar)
+         *         ^^^
+         *
+ */ @Nullable public final ArgumentsNode arguments; + /** + * 
+         * Represents the block that is being passed to the method.
+         *
+         *     foo { |a| a }
+         *         ^^^^^^^^^
+         *
+ */ @Nullable + @UnionType({ BlockNode.class, BlockArgumentNode.class }) public final Node block; - public CallNode(short flags, Node receiver, org.jruby.RubySymbol name, ArgumentsNode arguments, Node block, int startOffset, int length) { + public CallNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol name, ArgumentsNode arguments, Node block) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -2291,19 +2585,19 @@ public CallNode(short flags, Node receiver, org.jruby.RubySymbol name, Arguments } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -2336,8 +2630,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -2366,14 +2660,54 @@ protected String toString(String indent) { */ public static final class CallOperatorWriteNode extends Node { public final short flags; + /** + * 
+         * The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     foo.bar += value
+         *     ^^^
+         *
+ */ @Nullable public final Node receiver; + /** + * 
+         * Represents the name of the method being called.
+         *
+         *     foo.bar += value # read_name `:bar`
+         *         ^^^
+         *
+ */ public final org.jruby.RubySymbol read_name; + /** + * 
+         * Represents the name of the method being written to.
+         *
+         *     foo.bar += value # write_name `:bar=`
+         *         ^^^
+         *
+ */ public final org.jruby.RubySymbol write_name; + /** + * 
+         * Represents the binary operator being used.
+         *
+         *     foo.bar += value # binary_operator `:+`
+         *             ^
+         *
+ */ public final org.jruby.RubySymbol binary_operator; + /** + * 
+         * Represents the value being assigned.
+         *
+         *     foo.bar += value
+         *                ^^^^^
+         *
+ */ public final Node value; - public CallOperatorWriteNode(short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, org.jruby.RubySymbol binary_operator, Node value, int startOffset, int length) { + public CallOperatorWriteNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, org.jruby.RubySymbol binary_operator, Node value) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -2384,19 +2718,19 @@ public CallOperatorWriteNode(short flags, Node receiver, org.jruby.RubySymbol re } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -2424,8 +2758,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -2459,13 +2793,45 @@ protected String toString(String indent) { */ public static final class CallOrWriteNode extends Node { public final short flags; + /** + * 
+         * The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     foo.bar ||= value
+         *     ^^^
+         *
+ */ @Nullable public final Node receiver; + /** + * 
+         * Represents the name of the method being called.
+         *
+         *     foo.bar ||= value # read_name `:bar`
+         *         ^^^
+         *
+ */ public final org.jruby.RubySymbol read_name; + /** + * 
+         * Represents the name of the method being written to.
+         *
+         *     foo.bar ||= value # write_name `:bar=`
+         *         ^^^
+         *
+ */ public final org.jruby.RubySymbol write_name; + /** + * 
+         * Represents the value being assigned.
+         *
+         *     foo.bar ||= value
+         *                 ^^^^^
+         *
+ */ public final Node value; - public CallOrWriteNode(short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, Node value, int startOffset, int length) { + public CallOrWriteNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, Node value) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -2475,19 +2841,19 @@ public CallOrWriteNode(short flags, Node receiver, org.jruby.RubySymbol read_nam } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -2515,8 +2881,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -2554,10 +2920,26 @@ protected String toString(String indent) { */ public static final class CallTargetNode extends Node { public final short flags; + /** + * 
+         * The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     foo.bar = 1
+         *     ^^^
+         *
+ */ public final Node receiver; + /** + * 
+         * Represents the name of the method being called.
+         *
+         *     foo.bar = 1 # name `:foo`
+         *     ^^^
+         *
+ */ public final org.jruby.RubySymbol name; - public CallTargetNode(short flags, Node receiver, org.jruby.RubySymbol name, int startOffset, int length) { + public CallTargetNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol name) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -2565,19 +2947,19 @@ public CallTargetNode(short flags, Node receiver, org.jruby.RubySymbol name, int } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -2602,8 +2984,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -2625,10 +3007,26 @@ protected String toString(String indent) { * */ public static final class CapturePatternNode extends Node { + /** + * 
+         * Represents the value to capture.
+         *
+         *     foo => bar
+         *            ^^^
+         *
+ */ public final Node value; - public final Node target; + /** + * 
+         * Represents the target of the capture.
+         *
+         *     foo => bar
+         *     ^^^
+         *
+ */ + public final LocalVariableTargetNode target; - public CapturePatternNode(Node value, Node target, int startOffset, int length) { + public CapturePatternNode(int startOffset, int length, Node value, LocalVariableTargetNode target) { super(startOffset, length); this.value = value; this.target = target; @@ -2677,17 +3075,41 @@ protected String toString(String indent) { * */ public static final class CaseMatchNode extends Node { + /** + * 
+         * Represents the predicate of the case match. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     case true; in false; end
+         *     ^^^^
+         *
+ */ @Nullable public final Node predicate; - public final Node[] conditions; + /** + * 
+         * Represents the conditions of the case match.
+         *
+         *     case true; in false; end
+         *                ^^^^^^^^
+         *
+ */ + public final InNode[] conditions; + /** + * 
+         * Represents the else clause of the case match.
+         *
+         *     case true; in false; else; end
+         *                          ^^^^
+         *
+ */ @Nullable - public final ElseNode consequent; + public final ElseNode else_clause; - public CaseMatchNode(Node predicate, Node[] conditions, ElseNode consequent, int startOffset, int length) { + public CaseMatchNode(int startOffset, int length, Node predicate, InNode[] conditions, ElseNode else_clause) { super(startOffset, length); this.predicate = predicate; this.conditions = conditions; - this.consequent = consequent; + this.else_clause = else_clause; } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -2697,8 +3119,8 @@ public void visitChildNodes(AbstractNodeVisitor visitor) { for (Nodes.Node child : this.conditions) { child.accept(visitor); } - if (this.consequent != null) { - this.consequent.accept(visitor); + if (this.else_clause != null) { + this.else_clause.accept(visitor); } } @@ -2706,7 +3128,7 @@ public Node[] childNodes() { ArrayList childNodes = new ArrayList<>(); childNodes.add(this.predicate); childNodes.addAll(Arrays.asList(this.conditions)); - childNodes.add(this.consequent); + childNodes.add(this.else_clause); return childNodes.toArray(EMPTY_ARRAY); } @@ -2734,8 +3156,8 @@ protected String toString(String indent) { builder.append(nextNextIndent).append(child.toString(nextNextIndent)); } builder.append(nextIndent); - builder.append("consequent: "); - builder.append(this.consequent == null ? "null\n" : this.consequent.toString(nextIndent)); + builder.append("else_clause: "); + builder.append(this.else_clause == null ? "null\n" : this.else_clause.toString(nextIndent)); return builder.toString(); } } @@ -2751,17 +3173,41 @@ protected String toString(String indent) { * */ public static final class CaseNode extends Node { + /** + * 
+         * Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     case true; when false; end
+         *     ^^^^
+         *
+ */ @Nullable public final Node predicate; - public final Node[] conditions; + /** + * 
+         * Represents the conditions of the case statement.
+         *
+         *     case true; when false; end
+         *                ^^^^^^^^^^
+         *
+ */ + public final WhenNode[] conditions; + /** + * 
+         * Represents the else clause of the case statement.
+         *
+         *     case true; when false; else; end
+         *                            ^^^^
+         *
+ */ @Nullable - public final ElseNode consequent; + public final ElseNode else_clause; - public CaseNode(Node predicate, Node[] conditions, ElseNode consequent, int startOffset, int length) { + public CaseNode(int startOffset, int length, Node predicate, WhenNode[] conditions, ElseNode else_clause) { super(startOffset, length); this.predicate = predicate; this.conditions = conditions; - this.consequent = consequent; + this.else_clause = else_clause; } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -2771,8 +3217,8 @@ public void visitChildNodes(AbstractNodeVisitor visitor) { for (Nodes.Node child : this.conditions) { child.accept(visitor); } - if (this.consequent != null) { - this.consequent.accept(visitor); + if (this.else_clause != null) { + this.else_clause.accept(visitor); } } @@ -2780,7 +3226,7 @@ public Node[] childNodes() { ArrayList childNodes = new ArrayList<>(); childNodes.add(this.predicate); childNodes.addAll(Arrays.asList(this.conditions)); - childNodes.add(this.consequent); + childNodes.add(this.else_clause); return childNodes.toArray(EMPTY_ARRAY); } @@ -2808,8 +3254,8 @@ protected String toString(String indent) { builder.append(nextNextIndent).append(child.toString(nextNextIndent)); } builder.append(nextIndent); - builder.append("consequent: "); - builder.append(this.consequent == null ? "null\n" : this.consequent.toString(nextIndent)); + builder.append("else_clause: "); + builder.append(this.else_clause == null ? "null\n" : this.else_clause.toString(nextIndent)); return builder.toString(); } } @@ -2824,14 +3270,16 @@ protected String toString(String indent) { */ public static final class ClassNode extends Node { public final org.jruby.RubySymbol[] locals; + @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) public final Node constant_path; @Nullable public final Node superclass; @Nullable + @UnionType({ StatementsNode.class, BeginNode.class }) public final Node body; public final org.jruby.RubySymbol name; - public ClassNode(org.jruby.RubySymbol[] locals, Node constant_path, Node superclass, Node body, org.jruby.RubySymbol name, int startOffset, int length) { + public ClassNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node constant_path, Node superclass, Node body, org.jruby.RubySymbol name) { super(startOffset, length); this.locals = locals; this.constant_path = constant_path; @@ -2900,10 +3348,26 @@ protected String toString(String indent) { * */ public static final class ClassVariableAndWriteNode extends Node { + /** + * 
+         * The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+         *
+         *     @@target &&= value # name `:@@target`
+         *     ^^^^^^^^
+         *
+ */ public final org.jruby.RubySymbol name; + /** + * 
+         * Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     @@target &&= value
+         *                  ^^^^^
+         *
+ */ public final Node value; - public ClassVariableAndWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public ClassVariableAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -2954,7 +3418,7 @@ public static final class ClassVariableOperatorWriteNode extends Node { public final Node value; public final org.jruby.RubySymbol binary_operator; - public ClassVariableOperatorWriteNode(org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator, int startOffset, int length) { + public ClassVariableOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { super(startOffset, length); this.name = name; this.value = value; @@ -3009,7 +3473,7 @@ public static final class ClassVariableOrWriteNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public ClassVariableOrWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public ClassVariableOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -3067,7 +3531,7 @@ public static final class ClassVariableReadNode extends Node { */ public final org.jruby.RubySymbol name; - public ClassVariableReadNode(org.jruby.RubySymbol name, int startOffset, int length) { + public ClassVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -3111,7 +3575,7 @@ protected String toString(String indent) { public static final class ClassVariableTargetNode extends Node { public final org.jruby.RubySymbol name; - public ClassVariableTargetNode(org.jruby.RubySymbol name, int startOffset, int length) { + public ClassVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -3176,7 +3640,7 @@ public static final class ClassVariableWriteNode extends Node { */ public final Node value; - public ClassVariableWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public ClassVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -3226,7 +3690,7 @@ public static final class ConstantAndWriteNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public ConstantAndWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public ConstantAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -3277,7 +3741,7 @@ public static final class ConstantOperatorWriteNode extends Node { public final Node value; public final org.jruby.RubySymbol binary_operator; - public ConstantOperatorWriteNode(org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator, int startOffset, int length) { + public ConstantOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { super(startOffset, length); this.name = name; this.value = value; @@ -3332,7 +3796,7 @@ public static final class ConstantOrWriteNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public ConstantOrWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public ConstantOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -3382,7 +3846,7 @@ public static final class ConstantPathAndWriteNode extends Node { public final ConstantPathNode target; public final Node value; - public ConstantPathAndWriteNode(ConstantPathNode target, Node value, int startOffset, int length) { + public ConstantPathAndWriteNode(int startOffset, int length, ConstantPathNode target, Node value) { super(startOffset, length); this.target = target; this.value = value; @@ -3453,7 +3917,7 @@ public static final class ConstantPathNode extends Node { @Nullable public final org.jruby.RubySymbol name; - public ConstantPathNode(Node parent, org.jruby.RubySymbol name, int startOffset, int length) { + public ConstantPathNode(int startOffset, int length, Node parent, org.jruby.RubySymbol name) { super(startOffset, length); this.parent = parent; this.name = name; @@ -3506,7 +3970,7 @@ public static final class ConstantPathOperatorWriteNode extends Node { public final Node value; public final org.jruby.RubySymbol binary_operator; - public ConstantPathOperatorWriteNode(ConstantPathNode target, Node value, org.jruby.RubySymbol binary_operator, int startOffset, int length) { + public ConstantPathOperatorWriteNode(int startOffset, int length, ConstantPathNode target, Node value, org.jruby.RubySymbol binary_operator) { super(startOffset, length); this.target = target; this.value = value; @@ -3561,7 +4025,7 @@ public static final class ConstantPathOrWriteNode extends Node { public final ConstantPathNode target; public final Node value; - public ConstantPathOrWriteNode(ConstantPathNode target, Node value, int startOffset, int length) { + public ConstantPathOrWriteNode(int startOffset, int length, ConstantPathNode target, Node value) { super(startOffset, length); this.target = target; this.value = value; @@ -3613,7 +4077,7 @@ public static final class ConstantPathTargetNode extends Node { @Nullable public final org.jruby.RubySymbol name; - public ConstantPathTargetNode(Node parent, org.jruby.RubySymbol name, int startOffset, int length) { + public ConstantPathTargetNode(int startOffset, int length, Node parent, org.jruby.RubySymbol name) { super(startOffset, length); this.parent = parent; this.name = name; @@ -3690,7 +4154,7 @@ public static final class ConstantPathWriteNode extends Node { */ public final Node value; - public ConstantPathWriteNode(ConstantPathNode target, Node value, int startOffset, int length) { + public ConstantPathWriteNode(int startOffset, int length, ConstantPathNode target, Node value) { super(startOffset, length); this.target = target; this.value = value; @@ -3748,7 +4212,7 @@ public static final class ConstantReadNode extends Node { */ public final org.jruby.RubySymbol name; - public ConstantReadNode(org.jruby.RubySymbol name, int startOffset, int length) { + public ConstantReadNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -3792,7 +4256,7 @@ protected String toString(String indent) { public static final class ConstantTargetNode extends Node { public final org.jruby.RubySymbol name; - public ConstantTargetNode(org.jruby.RubySymbol name, int startOffset, int length) { + public ConstantTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -3857,7 +4321,7 @@ public static final class ConstantWriteNode extends Node { */ public final Node value; - public ConstantWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public ConstantWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -3912,10 +4376,11 @@ public static final class DefNode extends Node { @Nullable public final ParametersNode parameters; @Nullable + @UnionType({ StatementsNode.class, BeginNode.class }) public final Node body; public final org.jruby.RubySymbol[] locals; - public DefNode(int serializedLength, org.jruby.RubySymbol name, Node receiver, ParametersNode parameters, Node body, org.jruby.RubySymbol[] locals, int startOffset, int length) { + public DefNode(int startOffset, int length, int serializedLength, org.jruby.RubySymbol name, Node receiver, ParametersNode parameters, Node body, org.jruby.RubySymbol[] locals) { super(startOffset, length); this.serializedLength = serializedLength; this.name = name; @@ -3989,7 +4454,7 @@ protected String toString(String indent) { public static final class DefinedNode extends Node { public final Node value; - public DefinedNode(Node value, int startOffset, int length) { + public DefinedNode(int startOffset, int length, Node value) { super(startOffset, length); this.value = value; } @@ -4034,7 +4499,7 @@ public static final class ElseNode extends Node { @Nullable public final StatementsNode statements; - public ElseNode(StatementsNode statements, int startOffset, int length) { + public ElseNode(int startOffset, int length, StatementsNode statements) { super(startOffset, length); this.statements = statements; } @@ -4081,7 +4546,7 @@ public static final class EmbeddedStatementsNode extends Node { @Nullable public final StatementsNode statements; - public EmbeddedStatementsNode(StatementsNode statements, int startOffset, int length) { + public EmbeddedStatementsNode(int startOffset, int length, StatementsNode statements) { super(startOffset, length); this.statements = statements; } @@ -4125,9 +4590,10 @@ protected String toString(String indent) { * */ public static final class EmbeddedVariableNode extends Node { + @UnionType({ InstanceVariableReadNode.class, ClassVariableReadNode.class, GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class }) public final Node variable; - public EmbeddedVariableNode(Node variable, int startOffset, int length) { + public EmbeddedVariableNode(int startOffset, int length, Node variable) { super(startOffset, length); this.variable = variable; } @@ -4176,7 +4642,7 @@ public static final class EnsureNode extends Node { @Nullable public final StatementsNode statements; - public EnsureNode(StatementsNode statements, int startOffset, int length) { + public EnsureNode(int startOffset, int length, StatementsNode statements) { super(startOffset, length); this.statements = statements; } @@ -4265,12 +4731,13 @@ protected String toString(String indent) { */ public static final class FindPatternNode extends Node { @Nullable + @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) public final Node constant; - public final Node left; + public final SplatNode left; public final Node[] requireds; - public final Node right; + public final SplatNode right; - public FindPatternNode(Node constant, Node left, Node[] requireds, Node right, int startOffset, int length) { + public FindPatternNode(int startOffset, int length, Node constant, SplatNode left, Node[] requireds, SplatNode right) { super(startOffset, length); this.constant = constant; this.left = left; @@ -4346,7 +4813,7 @@ public static final class FlipFlopNode extends Node { @Nullable public final Node right; - public FlipFlopNode(short flags, Node left, Node right, int startOffset, int length) { + public FlipFlopNode(int startOffset, int length, short flags, Node left, Node right) { super(startOffset, length); this.flags = flags; this.left = left; @@ -4354,7 +4821,7 @@ public FlipFlopNode(short flags, Node left, Node right, int startOffset, int len } public boolean isExcludeEnd() { - return RangeFlags.isExcludeEnd(this.flags); + return RangeFlags.isExcludeEnd(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -4384,8 +4851,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("RangeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("left: "); @@ -4413,7 +4880,7 @@ public static final class FloatNode extends Node { */ public final double value; - public FloatNode(double value, int startOffset, int length) { + public FloatNode(int startOffset, int length, double value) { super(startOffset, length); this.value = value; } @@ -4455,12 +4922,39 @@ protected String toString(String indent) { * */ public static final class ForNode extends Node { + /** + * 
+         * The index expression for `for` loops.
+         *
+         *     for i in a end
+         *         ^
+         *
+ */ + @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class }) public final Node index; + /** + * 
+         * The collection to iterate over.
+         *
+         *     for i in a end
+         *              ^
+         *
+ */ public final Node collection; + /** + * 
+         * Represents the body of statements to execute for each iteration of the loop.
+         *
+         *     for i in a
+         *       foo(i)
+         *       ^^^^^^
+         *     end
+         *
+ */ @Nullable public final StatementsNode statements; - public ForNode(Node index, Node collection, StatementsNode statements, int startOffset, int length) { + public ForNode(int startOffset, int length, Node index, Node collection, StatementsNode statements) { super(startOffset, length); this.index = index; this.collection = collection; @@ -4596,7 +5090,7 @@ public static final class ForwardingSuperNode extends Node { @Nullable public final BlockNode block; - public ForwardingSuperNode(BlockNode block, int startOffset, int length) { + public ForwardingSuperNode(int startOffset, int length, BlockNode block) { super(startOffset, length); this.block = block; } @@ -4643,7 +5137,7 @@ public static final class GlobalVariableAndWriteNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public GlobalVariableAndWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public GlobalVariableAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -4694,7 +5188,7 @@ public static final class GlobalVariableOperatorWriteNode extends Node { public final Node value; public final org.jruby.RubySymbol binary_operator; - public GlobalVariableOperatorWriteNode(org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator, int startOffset, int length) { + public GlobalVariableOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { super(startOffset, length); this.name = name; this.value = value; @@ -4749,7 +5243,7 @@ public static final class GlobalVariableOrWriteNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public GlobalVariableOrWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public GlobalVariableOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -4807,7 +5301,7 @@ public static final class GlobalVariableReadNode extends Node { */ public final org.jruby.RubySymbol name; - public GlobalVariableReadNode(org.jruby.RubySymbol name, int startOffset, int length) { + public GlobalVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -4851,7 +5345,7 @@ protected String toString(String indent) { public static final class GlobalVariableTargetNode extends Node { public final org.jruby.RubySymbol name; - public GlobalVariableTargetNode(org.jruby.RubySymbol name, int startOffset, int length) { + public GlobalVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -4916,7 +5410,7 @@ public static final class GlobalVariableWriteNode extends Node { */ public final Node value; - public GlobalVariableWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public GlobalVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -4977,7 +5471,7 @@ public static final class HashNode extends Node { @UnionType({ AssocNode.class, AssocSplatNode.class }) public final Node[] elements; - public HashNode(Node[] elements, int startOffset, int length) { + public HashNode(int startOffset, int length, Node[] elements) { super(startOffset, length); this.elements = elements; } @@ -5031,13 +5525,14 @@ protected String toString(String indent) { */ public static final class HashPatternNode extends Node { @Nullable + @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) public final Node constant; public final AssocNode[] elements; @Nullable @UnionType({ AssocSplatNode.class, NoKeywordsParameterNode.class }) public final Node rest; - public HashPatternNode(Node constant, AssocNode[] elements, Node rest, int startOffset, int length) { + public HashPatternNode(int startOffset, int length, Node constant, AssocNode[] elements, Node rest) { super(startOffset, length); this.constant = constant; this.elements = elements; @@ -5158,13 +5653,14 @@ public static final class IfNode extends Node { * */ @Nullable - public final Node consequent; + @UnionType({ ElseNode.class, IfNode.class }) + public final Node subsequent; - public IfNode(Node predicate, StatementsNode statements, Node consequent, int startOffset, int length) { + public IfNode(int startOffset, int length, Node predicate, StatementsNode statements, Node subsequent) { super(startOffset, length); this.predicate = predicate; this.statements = statements; - this.consequent = consequent; + this.subsequent = subsequent; } @Override @@ -5177,13 +5673,13 @@ public void visitChildNodes(AbstractNodeVisitor visitor) { if (this.statements != null) { this.statements.accept(visitor); } - if (this.consequent != null) { - this.consequent.accept(visitor); + if (this.subsequent != null) { + this.subsequent.accept(visitor); } } public Node[] childNodes() { - return new Node[] { this.predicate, this.statements, this.consequent }; + return new Node[] { this.predicate, this.statements, this.subsequent }; } public T accept(AbstractNodeVisitor visitor) { @@ -5206,8 +5702,8 @@ protected String toString(String indent) { builder.append("statements: "); builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); builder.append(nextIndent); - builder.append("consequent: "); - builder.append(this.consequent == null ? "null\n" : this.consequent.toString(nextIndent)); + builder.append("subsequent: "); + builder.append(this.subsequent == null ? "null\n" : this.subsequent.toString(nextIndent)); return builder.toString(); } } @@ -5224,7 +5720,7 @@ public static final class ImaginaryNode extends Node { @UnionType({ FloatNode.class, IntegerNode.class, RationalNode.class }) public final Node numeric; - public ImaginaryNode(Node numeric, int startOffset, int length) { + public ImaginaryNode(int startOffset, int length, Node numeric) { super(startOffset, length); this.numeric = numeric; } @@ -5272,9 +5768,10 @@ protected String toString(String indent) { * */ public static final class ImplicitNode extends Node { + @UnionType({ LocalVariableReadNode.class, CallNode.class, ConstantReadNode.class, LocalVariableTargetNode.class }) public final Node value; - public ImplicitNode(Node value, int startOffset, int length) { + public ImplicitNode(int startOffset, int length, Node value) { super(startOffset, length); this.value = value; } @@ -5367,7 +5864,7 @@ public static final class InNode extends Node { @Nullable public final StatementsNode statements; - public InNode(Node pattern, StatementsNode statements, int startOffset, int length) { + public InNode(int startOffset, int length, Node pattern, StatementsNode statements) { super(startOffset, length); this.pattern = pattern; this.statements = statements; @@ -5422,10 +5919,10 @@ public static final class IndexAndWriteNode extends Node { @Nullable public final ArgumentsNode arguments; @Nullable - public final Node block; + public final BlockArgumentNode block; public final Node value; - public IndexAndWriteNode(short flags, Node receiver, ArgumentsNode arguments, Node block, Node value, int startOffset, int length) { + public IndexAndWriteNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block, Node value) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -5435,19 +5932,19 @@ public IndexAndWriteNode(short flags, Node receiver, ArgumentsNode arguments, No } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -5481,8 +5978,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -5515,11 +6012,11 @@ public static final class IndexOperatorWriteNode extends Node { @Nullable public final ArgumentsNode arguments; @Nullable - public final Node block; + public final BlockArgumentNode block; public final org.jruby.RubySymbol binary_operator; public final Node value; - public IndexOperatorWriteNode(short flags, Node receiver, ArgumentsNode arguments, Node block, org.jruby.RubySymbol binary_operator, Node value, int startOffset, int length) { + public IndexOperatorWriteNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block, org.jruby.RubySymbol binary_operator, Node value) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -5530,19 +6027,19 @@ public IndexOperatorWriteNode(short flags, Node receiver, ArgumentsNode argument } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -5576,8 +6073,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -5614,10 +6111,10 @@ public static final class IndexOrWriteNode extends Node { @Nullable public final ArgumentsNode arguments; @Nullable - public final Node block; + public final BlockArgumentNode block; public final Node value; - public IndexOrWriteNode(short flags, Node receiver, ArgumentsNode arguments, Node block, Node value, int startOffset, int length) { + public IndexOrWriteNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block, Node value) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -5627,19 +6124,19 @@ public IndexOrWriteNode(short flags, Node receiver, ArgumentsNode arguments, Nod } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -5673,8 +6170,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -5714,9 +6211,9 @@ public static final class IndexTargetNode extends Node { @Nullable public final ArgumentsNode arguments; @Nullable - public final Node block; + public final BlockArgumentNode block; - public IndexTargetNode(short flags, Node receiver, ArgumentsNode arguments, Node block, int startOffset, int length) { + public IndexTargetNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block) { super(startOffset, length); this.flags = flags; this.receiver = receiver; @@ -5725,19 +6222,19 @@ public IndexTargetNode(short flags, Node receiver, ArgumentsNode arguments, Node } public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(this.flags); + return CallNodeFlags.isSafeNavigation(flags); } public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(this.flags); + return CallNodeFlags.isVariableCall(flags); } public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(this.flags); + return CallNodeFlags.isAttributeWrite(flags); } public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(this.flags); + return CallNodeFlags.isIgnoreVisibility(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -5768,8 +6265,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("CallNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("receiver: "); @@ -5796,7 +6293,7 @@ public static final class InstanceVariableAndWriteNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public InstanceVariableAndWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public InstanceVariableAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -5847,7 +6344,7 @@ public static final class InstanceVariableOperatorWriteNode extends Node { public final Node value; public final org.jruby.RubySymbol binary_operator; - public InstanceVariableOperatorWriteNode(org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator, int startOffset, int length) { + public InstanceVariableOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { super(startOffset, length); this.name = name; this.value = value; @@ -5902,7 +6399,7 @@ public static final class InstanceVariableOrWriteNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public InstanceVariableOrWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public InstanceVariableOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -5960,7 +6457,7 @@ public static final class InstanceVariableReadNode extends Node { */ public final org.jruby.RubySymbol name; - public InstanceVariableReadNode(org.jruby.RubySymbol name, int startOffset, int length) { + public InstanceVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -6004,7 +6501,7 @@ protected String toString(String indent) { public static final class InstanceVariableTargetNode extends Node { public final org.jruby.RubySymbol name; - public InstanceVariableTargetNode(org.jruby.RubySymbol name, int startOffset, int length) { + public InstanceVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { super(startOffset, length); this.name = name; } @@ -6069,7 +6566,7 @@ public static final class InstanceVariableWriteNode extends Node { */ public final Node value; - public InstanceVariableWriteNode(org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public InstanceVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.name = name; this.value = value; @@ -6124,26 +6621,26 @@ public static final class IntegerNode extends Node { */ public final Object value; - public IntegerNode(short flags, Object value, int startOffset, int length) { + public IntegerNode(int startOffset, int length, short flags, Object value) { super(startOffset, length); this.flags = flags; this.value = value; } public boolean isBinary() { - return IntegerBaseFlags.isBinary(this.flags); + return IntegerBaseFlags.isBinary(flags); } public boolean isDecimal() { - return IntegerBaseFlags.isDecimal(this.flags); + return IntegerBaseFlags.isDecimal(flags); } public boolean isOctal() { - return IntegerBaseFlags.isOctal(this.flags); + return IntegerBaseFlags.isOctal(flags); } public boolean isHexadecimal() { - return IntegerBaseFlags.isHexadecimal(this.flags); + return IntegerBaseFlags.isHexadecimal(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -6167,8 +6664,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("IntegerBaseFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("value: "); @@ -6191,54 +6688,54 @@ public static final class InterpolatedMatchLastLineNode extends Node { @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) public final Node[] parts; - public InterpolatedMatchLastLineNode(short flags, Node[] parts, int startOffset, int length) { + public InterpolatedMatchLastLineNode(int startOffset, int length, short flags, Node[] parts) { super(startOffset, length); this.flags = flags; this.parts = parts; } public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(this.flags); + return RegularExpressionFlags.isIgnoreCase(flags); } public boolean isExtended() { - return RegularExpressionFlags.isExtended(this.flags); + return RegularExpressionFlags.isExtended(flags); } public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(this.flags); + return RegularExpressionFlags.isMultiLine(flags); } public boolean isOnce() { - return RegularExpressionFlags.isOnce(this.flags); + return RegularExpressionFlags.isOnce(flags); } public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(this.flags); + return RegularExpressionFlags.isEucJp(flags); } public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(this.flags); + return RegularExpressionFlags.isAscii8bit(flags); } public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(this.flags); + return RegularExpressionFlags.isWindows31j(flags); } public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(this.flags); + return RegularExpressionFlags.isUtf8(flags); } public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(this.flags); + return RegularExpressionFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(this.flags); + return RegularExpressionFlags.isForcedBinaryEncoding(flags); } public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(this.flags); + return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); } @Override @@ -6276,8 +6773,8 @@ protected String toString(String indent) { String nextIndent = indent + " "; String nextNextIndent = nextIndent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("RegularExpressionFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("parts: "); @@ -6302,54 +6799,54 @@ public static final class InterpolatedRegularExpressionNode extends Node { @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) public final Node[] parts; - public InterpolatedRegularExpressionNode(short flags, Node[] parts, int startOffset, int length) { + public InterpolatedRegularExpressionNode(int startOffset, int length, short flags, Node[] parts) { super(startOffset, length); this.flags = flags; this.parts = parts; } public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(this.flags); + return RegularExpressionFlags.isIgnoreCase(flags); } public boolean isExtended() { - return RegularExpressionFlags.isExtended(this.flags); + return RegularExpressionFlags.isExtended(flags); } public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(this.flags); + return RegularExpressionFlags.isMultiLine(flags); } public boolean isOnce() { - return RegularExpressionFlags.isOnce(this.flags); + return RegularExpressionFlags.isOnce(flags); } public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(this.flags); + return RegularExpressionFlags.isEucJp(flags); } public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(this.flags); + return RegularExpressionFlags.isAscii8bit(flags); } public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(this.flags); + return RegularExpressionFlags.isWindows31j(flags); } public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(this.flags); + return RegularExpressionFlags.isUtf8(flags); } public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(this.flags); + return RegularExpressionFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(this.flags); + return RegularExpressionFlags.isForcedBinaryEncoding(flags); } public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(this.flags); + return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); } @Override @@ -6387,8 +6884,8 @@ protected String toString(String indent) { String nextIndent = indent + " "; String nextNextIndent = nextIndent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("RegularExpressionFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("parts: "); @@ -6413,18 +6910,18 @@ public static final class InterpolatedStringNode extends Node { @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class, InterpolatedStringNode.class }) public final Node[] parts; - public InterpolatedStringNode(short flags, Node[] parts, int startOffset, int length) { + public InterpolatedStringNode(int startOffset, int length, short flags, Node[] parts) { super(startOffset, length); this.flags = flags; this.parts = parts; } public boolean isFrozen() { - return InterpolatedStringNodeFlags.isFrozen(this.flags); + return InterpolatedStringNodeFlags.isFrozen(flags); } public boolean isMutable() { - return InterpolatedStringNodeFlags.isMutable(this.flags); + return InterpolatedStringNodeFlags.isMutable(flags); } @Override @@ -6462,8 +6959,8 @@ protected String toString(String indent) { String nextIndent = indent + " "; String nextNextIndent = nextIndent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("InterpolatedStringNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("parts: "); @@ -6487,7 +6984,7 @@ public static final class InterpolatedSymbolNode extends Node { @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) public final Node[] parts; - public InterpolatedSymbolNode(Node[] parts, int startOffset, int length) { + public InterpolatedSymbolNode(int startOffset, int length, Node[] parts) { super(startOffset, length); this.parts = parts; } @@ -6548,7 +7045,7 @@ public static final class InterpolatedXStringNode extends Node { @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) public final Node[] parts; - public InterpolatedXStringNode(Node[] parts, int startOffset, int length) { + public InterpolatedXStringNode(int startOffset, int length, Node[] parts) { super(startOffset, length); this.parts = parts; } @@ -6597,6 +7094,44 @@ protected String toString(String indent) { } } + /** + * 
+     * Represents reading from the implicit `it` local variable.
+     *
+     *     -> { it }
+     *          ^^
+     *
+ */ + public static final class ItLocalVariableReadNode extends Node { + + public ItLocalVariableReadNode(int startOffset, int length) { + super(startOffset, length); + } + + public void visitChildNodes(AbstractNodeVisitor visitor) { + } + + public Node[] childNodes() { + return EMPTY_ARRAY; + } + + public T accept(AbstractNodeVisitor visitor) { + return visitor.visitItLocalVariableReadNode(this); + } + + @Override + protected String toString(String indent) { + StringBuilder builder = new StringBuilder(); + builder.append(this.getClass().getSimpleName()); + if (hasNewLineFlag()) { + builder.append("[Li]"); + } + builder.append('\n'); + String nextIndent = indent + " "; + return builder.toString(); + } + } + /** * 
      * Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
@@ -6648,14 +7183,14 @@ public static final class KeywordHashNode extends Node {
         @UnionType({ AssocNode.class, AssocSplatNode.class })
         public final Node[] elements;
 
-        public KeywordHashNode(short flags, Node[] elements, int startOffset, int length) {
+        public KeywordHashNode(int startOffset, int length, short flags, Node[] elements) {
             super(startOffset, length);
             this.flags = flags;
             this.elements = elements;
         }
         
         public boolean isSymbolKeys() {
-            return KeywordHashNodeFlags.isSymbolKeys(this.flags);
+            return KeywordHashNodeFlags.isSymbolKeys(flags);
         }
         
         public  void visitChildNodes(AbstractNodeVisitor visitor) {
@@ -6685,8 +7220,8 @@ protected String toString(String indent) {
             String nextIndent = indent + "  ";
             String nextNextIndent = nextIndent + "  ";
             builder.append(nextIndent);
-            builder.append("flags: ");
-            builder.append(this.flags);
+            builder.append("KeywordHashNodeFlags: ");
+            builder.append(flags);
             builder.append('\n');
             builder.append(nextIndent);
             builder.append("elements: ");
@@ -6712,14 +7247,14 @@ public static final class KeywordRestParameterNode extends Node {
         @Nullable
         public final org.jruby.RubySymbol name;
 
-        public KeywordRestParameterNode(short flags, org.jruby.RubySymbol name, int startOffset, int length) {
+        public KeywordRestParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) {
             super(startOffset, length);
             this.flags = flags;
             this.name = name;
         }
         
         public boolean isRepeatedParameter() {
-            return ParameterFlags.isRepeatedParameter(this.flags);
+            return ParameterFlags.isRepeatedParameter(flags);
         }
         
         public  void visitChildNodes(AbstractNodeVisitor visitor) {
@@ -6743,8 +7278,8 @@ protected String toString(String indent) {
             builder.append('\n');
             String nextIndent = indent + "  ";
             builder.append(nextIndent);
-            builder.append("flags: ");
-            builder.append(this.flags);
+            builder.append("ParameterFlags: ");
+            builder.append(flags);
             builder.append('\n');
             builder.append(nextIndent);
             builder.append("name: ");
@@ -6765,11 +7300,13 @@ protected String toString(String indent) {
     public static final class LambdaNode extends Node {
         public final org.jruby.RubySymbol[] locals;
         @Nullable
+        @UnionType({ BlockParametersNode.class, NumberedParametersNode.class, ItParametersNode.class })
         public final Node parameters;
         @Nullable
+        @UnionType({ StatementsNode.class, BeginNode.class })
         public final Node body;
 
-        public LambdaNode(org.jruby.RubySymbol[] locals, Node parameters, Node body, int startOffset, int length) {
+        public LambdaNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node parameters, Node body) {
             super(startOffset, length);
             this.locals = locals;
             this.parameters = parameters;
@@ -6832,7 +7369,7 @@ public static final class LocalVariableAndWriteNode extends Node {
         public final org.jruby.RubySymbol name;
         public final int depth;
 
-        public LocalVariableAndWriteNode(Node value, org.jruby.RubySymbol name, int depth, int startOffset, int length) {
+        public LocalVariableAndWriteNode(int startOffset, int length, Node value, org.jruby.RubySymbol name, int depth) {
             super(startOffset, length);
             this.value = value;
             this.name = name;
@@ -6889,7 +7426,7 @@ public static final class LocalVariableOperatorWriteNode extends Node {
         public final org.jruby.RubySymbol binary_operator;
         public final int depth;
 
-        public LocalVariableOperatorWriteNode(Node value, org.jruby.RubySymbol name, org.jruby.RubySymbol binary_operator, int depth, int startOffset, int length) {
+        public LocalVariableOperatorWriteNode(int startOffset, int length, Node value, org.jruby.RubySymbol name, org.jruby.RubySymbol binary_operator, int depth) {
             super(startOffset, length);
             this.value = value;
             this.name = name;
@@ -6950,7 +7487,7 @@ public static final class LocalVariableOrWriteNode extends Node {
         public final org.jruby.RubySymbol name;
         public final int depth;
 
-        public LocalVariableOrWriteNode(Node value, org.jruby.RubySymbol name, int depth, int startOffset, int length) {
+        public LocalVariableOrWriteNode(int startOffset, int length, Node value, org.jruby.RubySymbol name, int depth) {
             super(startOffset, length);
             this.value = value;
             this.name = name;
@@ -7013,10 +7550,6 @@ public static final class LocalVariableReadNode extends Node {
          * Note that this can also be an underscore followed by a number for the default block parameters.
          *
          *     _1     # name `:_1`
-         *
-         * Finally, for the default `it` block parameter, the name is `0it`. This is to distinguish it from an `it` local variable that is explicitly declared.
-         *
-         *     it     # name `:0it`
          *
*/ public final org.jruby.RubySymbol name; @@ -7033,7 +7566,7 @@ public static final class LocalVariableReadNode extends Node { */ public final int depth; - public LocalVariableReadNode(org.jruby.RubySymbol name, int depth, int startOffset, int length) { + public LocalVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name, int depth) { super(startOffset, length); this.name = name; this.depth = depth; @@ -7083,7 +7616,7 @@ public static final class LocalVariableTargetNode extends Node { public final org.jruby.RubySymbol name; public final int depth; - public LocalVariableTargetNode(org.jruby.RubySymbol name, int depth, int startOffset, int length) { + public LocalVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name, int depth) { super(startOffset, length); this.name = name; this.depth = depth; @@ -7169,7 +7702,7 @@ public static final class LocalVariableWriteNode extends Node { */ public final Node value; - public LocalVariableWriteNode(org.jruby.RubySymbol name, int depth, Node value, int startOffset, int length) { + public LocalVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, int depth, Node value) { super(startOffset, length); this.name = name; this.depth = depth; @@ -7224,54 +7757,54 @@ public static final class MatchLastLineNode extends Node { public final short flags; public final byte[] unescaped; - public MatchLastLineNode(short flags, byte[] unescaped, int startOffset, int length) { + public MatchLastLineNode(int startOffset, int length, short flags, byte[] unescaped) { super(startOffset, length); this.flags = flags; this.unescaped = unescaped; } public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(this.flags); + return RegularExpressionFlags.isIgnoreCase(flags); } public boolean isExtended() { - return RegularExpressionFlags.isExtended(this.flags); + return RegularExpressionFlags.isExtended(flags); } public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(this.flags); + return RegularExpressionFlags.isMultiLine(flags); } public boolean isOnce() { - return RegularExpressionFlags.isOnce(this.flags); + return RegularExpressionFlags.isOnce(flags); } public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(this.flags); + return RegularExpressionFlags.isEucJp(flags); } public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(this.flags); + return RegularExpressionFlags.isAscii8bit(flags); } public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(this.flags); + return RegularExpressionFlags.isWindows31j(flags); } public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(this.flags); + return RegularExpressionFlags.isUtf8(flags); } public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(this.flags); + return RegularExpressionFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(this.flags); + return RegularExpressionFlags.isForcedBinaryEncoding(flags); } public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(this.flags); + return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -7295,8 +7828,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("RegularExpressionFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("unescaped: "); @@ -7318,7 +7851,7 @@ public static final class MatchPredicateNode extends Node { public final Node value; public final Node pattern; - public MatchPredicateNode(Node value, Node pattern, int startOffset, int length) { + public MatchPredicateNode(int startOffset, int length, Node value, Node pattern) { super(startOffset, length); this.value = value; this.pattern = pattern; @@ -7368,7 +7901,7 @@ public static final class MatchRequiredNode extends Node { public final Node value; public final Node pattern; - public MatchRequiredNode(Node value, Node pattern, int startOffset, int length) { + public MatchRequiredNode(int startOffset, int length, Node value, Node pattern) { super(startOffset, length); this.value = value; this.pattern = pattern; @@ -7418,7 +7951,7 @@ public static final class MatchWriteNode extends Node { public final CallNode call; public final LocalVariableTargetNode[] targets; - public MatchWriteNode(CallNode call, LocalVariableTargetNode[] targets, int startOffset, int length) { + public MatchWriteNode(int startOffset, int length, CallNode call, LocalVariableTargetNode[] targets) { super(startOffset, length); this.call = call; this.targets = targets; @@ -7510,12 +8043,14 @@ protected String toString(String indent) { */ public static final class ModuleNode extends Node { public final org.jruby.RubySymbol[] locals; + @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) public final Node constant_path; @Nullable + @UnionType({ StatementsNode.class, BeginNode.class }) public final Node body; public final org.jruby.RubySymbol name; - public ModuleNode(org.jruby.RubySymbol[] locals, Node constant_path, Node body, org.jruby.RubySymbol name, int startOffset, int length) { + public ModuleNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node constant_path, Node body, org.jruby.RubySymbol name) { super(startOffset, length); this.locals = locals; this.constant_path = constant_path; @@ -7574,17 +8109,62 @@ protected String toString(String indent) { * * a, (b, c) = 1, 2, 3 * ^^^^^^ + * + * This can be a part of `MultiWriteNode` as above, or the target of a `for` loop + * + * for a, b in [[1, 2], [3, 4]] + * ^^^^ * */ public static final class MultiTargetNode extends Node { - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class, RequiredParameterNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class }) + /** + * 
+         * Represents the targets expressions before a splat node.
+         *
+         *     a, (b, c, *) = 1, 2, 3, 4, 5
+         *         ^^^^
+         *
+         * The splat node can be absent, in that case all target expressions are in the left field.
+         *
+         *     a, (b, c) = 1, 2, 3, 4, 5
+         *         ^^^^
+         *
+ */ + @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class, RequiredParameterNode.class }) public final Node[] lefts; + /** + * 
+         * Represents a splat node in the target expression.
+         *
+         *     a, (b, *c) = 1, 2, 3, 4
+         *            ^^
+         *
+         * The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+         *
+         *     a, (b, *) = 1, 2, 3, 4
+         *            ^
+         *
+         * If the `*` is omitted, this field will contain an `ImplicitRestNode`
+         *
+         *     a, (b,) = 1, 2, 3, 4
+         *          ^
+         *
+ */ @Nullable + @UnionType({ ImplicitRestNode.class, SplatNode.class }) public final Node rest; - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class, RequiredParameterNode.class, BackReferenceReadNode.class }) + /** + * 
+         * Represents the targets expressions after a splat node.
+         *
+         *     a, (*, b, c) = 1, 2, 3, 4, 5
+         *            ^^^^
+         *
+ */ + @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class, RequiredParameterNode.class }) public final Node[] rights; - public MultiTargetNode(Node[] lefts, Node rest, Node[] rights, int startOffset, int length) { + public MultiTargetNode(int startOffset, int length, Node[] lefts, Node rest, Node[] rights) { super(startOffset, length); this.lefts = lefts; this.rest = rest; @@ -7653,15 +8233,63 @@ protected String toString(String indent) { * */ public static final class MultiWriteNode extends Node { + /** + * 
+         * Represents the targets expressions before a splat node.
+         *
+         *     a, b, * = 1, 2, 3, 4, 5
+         *     ^^^^
+         *
+         * The splat node can be absent, in that case all target expressions are in the left field.
+         *
+         *     a, b, c = 1, 2, 3, 4, 5
+         *     ^^^^^^^
+         *
+ */ @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class }) public final Node[] lefts; + /** + * 
+         * Represents a splat node in the target expression.
+         *
+         *     a, b, *c = 1, 2, 3, 4
+         *           ^^
+         *
+         * The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+         *
+         *     a, b, * = 1, 2, 3, 4
+         *           ^
+         *
+         * If the `*` is omitted, this field will contain an `ImplicitRestNode`
+         *
+         *     a, b, = 1, 2, 3, 4
+         *         ^
+         *
+ */ @Nullable + @UnionType({ ImplicitRestNode.class, SplatNode.class }) public final Node rest; + /** + * 
+         * Represents the targets expressions after a splat node.
+         *
+         *     a, *, b, c = 1, 2, 3, 4, 5
+         *           ^^^^
+         *
+ */ @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class }) public final Node[] rights; + /** + * 
+         * The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         *
+         *     a, b, c = 1, 2, 3
+         *               ^^^^^^^
+         *
+ */ public final Node value; - public MultiWriteNode(Node[] lefts, Node rest, Node[] rights, Node value, int startOffset, int length) { + public MultiWriteNode(int startOffset, int length, Node[] lefts, Node rest, Node[] rights, Node value) { super(startOffset, length); this.lefts = lefts; this.rest = rest; @@ -7739,7 +8367,7 @@ public static final class NextNode extends Node { @Nullable public final ArgumentsNode arguments; - public NextNode(ArgumentsNode arguments, int startOffset, int length) { + public NextNode(int startOffset, int length, ArgumentsNode arguments) { super(startOffset, length); this.arguments = arguments; } @@ -7862,7 +8490,7 @@ protected String toString(String indent) { public static final class NumberedParametersNode extends Node { public final int maximum; - public NumberedParametersNode(int maximum, int startOffset, int length) { + public NumberedParametersNode(int startOffset, int length, int maximum) { super(startOffset, length); this.maximum = maximum; } @@ -7917,7 +8545,7 @@ public static final class NumberedReferenceReadNode extends Node { */ public final int number; - public NumberedReferenceReadNode(int number, int startOffset, int length) { + public NumberedReferenceReadNode(int startOffset, int length, int number) { super(startOffset, length); this.number = number; } @@ -7964,7 +8592,7 @@ public static final class OptionalKeywordParameterNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public OptionalKeywordParameterNode(short flags, org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public OptionalKeywordParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.flags = flags; this.name = name; @@ -7972,7 +8600,7 @@ public OptionalKeywordParameterNode(short flags, org.jruby.RubySymbol name, Node } public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(this.flags); + return ParameterFlags.isRepeatedParameter(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -7997,8 +8625,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("ParameterFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("name: "); @@ -8025,7 +8653,7 @@ public static final class OptionalParameterNode extends Node { public final org.jruby.RubySymbol name; public final Node value; - public OptionalParameterNode(short flags, org.jruby.RubySymbol name, Node value, int startOffset, int length) { + public OptionalParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name, Node value) { super(startOffset, length); this.flags = flags; this.name = name; @@ -8033,7 +8661,7 @@ public OptionalParameterNode(short flags, org.jruby.RubySymbol name, Node value, } public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(this.flags); + return ParameterFlags.isRepeatedParameter(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -8058,8 +8686,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("ParameterFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("name: "); @@ -8095,7 +8723,7 @@ public static final class OrNode extends Node { public final Node left; /** * 
-         * Represents the right side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+         * Represents the right side of the expression.
          *
          *     left || right
          *             ^^^^^
@@ -8106,7 +8734,7 @@ public static final class OrNode extends Node {
          */
         public final Node right;
 
-        public OrNode(Node left, Node right, int startOffset, int length) {
+        public OrNode(int startOffset, int length, Node left, Node right) {
             super(startOffset, length);
             this.left = left;
             this.right = right;
@@ -8160,7 +8788,7 @@ public static final class ParametersNode extends Node {
         @Nullable
         @UnionType({ RestParameterNode.class, ImplicitRestNode.class })
         public final Node rest;
-        @UnionType({ RequiredParameterNode.class, MultiTargetNode.class, KeywordRestParameterNode.class, NoKeywordsParameterNode.class, ForwardingParameterNode.class })
+        @UnionType({ RequiredParameterNode.class, MultiTargetNode.class })
         public final Node[] posts;
         @UnionType({ RequiredKeywordParameterNode.class, OptionalKeywordParameterNode.class })
         public final Node[] keywords;
@@ -8170,7 +8798,7 @@ public static final class ParametersNode extends Node {
         @Nullable
         public final BlockParameterNode block;
 
-        public ParametersNode(Node[] requireds, OptionalParameterNode[] optionals, Node rest, Node[] posts, Node[] keywords, Node keyword_rest, BlockParameterNode block, int startOffset, int length) {
+        public ParametersNode(int startOffset, int length, Node[] requireds, OptionalParameterNode[] optionals, Node rest, Node[] posts, Node[] keywords, Node keyword_rest, BlockParameterNode block) {
             super(startOffset, length);
             this.requireds = requireds;
             this.optionals = optionals;
@@ -8277,14 +8905,20 @@ protected String toString(String indent) {
      *
*/ public static final class ParenthesesNode extends Node { + public final short flags; @Nullable public final Node body; - public ParenthesesNode(Node body, int startOffset, int length) { + public ParenthesesNode(int startOffset, int length, short flags, Node body) { super(startOffset, length); + this.flags = flags; this.body = body; } - + + public boolean isMultipleStatements() { + return ParenthesesNodeFlags.isMultipleStatements(flags); + } + @Override public void setNewLineFlag(Source source, boolean[] newlineMarked) { // Never mark ParenthesesNode with a newline flag, mark children instead @@ -8314,6 +8948,10 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); + builder.append("ParenthesesNodeFlags: "); + builder.append(flags); + builder.append('\n'); + builder.append(nextIndent); builder.append("body: "); builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); return builder.toString(); @@ -8331,7 +8969,7 @@ protected String toString(String indent) { public static final class PinnedExpressionNode extends Node { public final Node expression; - public PinnedExpressionNode(Node expression, int startOffset, int length) { + public PinnedExpressionNode(int startOffset, int length, Node expression) { super(startOffset, length); this.expression = expression; } @@ -8373,9 +9011,10 @@ protected String toString(String indent) { * */ public static final class PinnedVariableNode extends Node { + @UnionType({ LocalVariableReadNode.class, InstanceVariableReadNode.class, ClassVariableReadNode.class, GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class, ItLocalVariableReadNode.class }) public final Node variable; - public PinnedVariableNode(Node variable, int startOffset, int length) { + public PinnedVariableNode(int startOffset, int length, Node variable) { super(startOffset, length); this.variable = variable; } @@ -8420,7 +9059,7 @@ public static final class PostExecutionNode extends Node { @Nullable public final StatementsNode statements; - public PostExecutionNode(StatementsNode statements, int startOffset, int length) { + public PostExecutionNode(int startOffset, int length, StatementsNode statements) { super(startOffset, length); this.statements = statements; } @@ -8467,7 +9106,7 @@ public static final class PreExecutionNode extends Node { @Nullable public final StatementsNode statements; - public PreExecutionNode(StatementsNode statements, int startOffset, int length) { + public PreExecutionNode(int startOffset, int length, StatementsNode statements) { super(startOffset, length); this.statements = statements; } @@ -8511,7 +9150,7 @@ public static final class ProgramNode extends Node { public final org.jruby.RubySymbol[] locals; public final StatementsNode statements; - public ProgramNode(org.jruby.RubySymbol[] locals, StatementsNode statements, int startOffset, int length) { + public ProgramNode(int startOffset, int length, org.jruby.RubySymbol[] locals, StatementsNode statements) { super(startOffset, length); this.locals = locals; this.statements = statements; @@ -8593,7 +9232,7 @@ public static final class RangeNode extends Node { @Nullable public final Node right; - public RangeNode(short flags, Node left, Node right, int startOffset, int length) { + public RangeNode(int startOffset, int length, short flags, Node left, Node right) { super(startOffset, length); this.flags = flags; this.left = left; @@ -8601,7 +9240,7 @@ public RangeNode(short flags, Node left, Node right, int startOffset, int length } public boolean isExcludeEnd() { - return RangeFlags.isExcludeEnd(this.flags); + return RangeFlags.isExcludeEnd(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -8631,8 +9270,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("RangeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("left: "); @@ -8653,19 +9292,52 @@ protected String toString(String indent) { * */ public static final class RationalNode extends Node { - public final Node numeric; + public final short flags; + /** + * 
+         * The numerator of the rational number.
+         *
+         *     1.5r # numerator 3
+         *
+ */ + public final Object numerator; + /** + * 
+         * The denominator of the rational number.
+         *
+         *     1.5r # denominator 2
+         *
+ */ + public final Object denominator; - public RationalNode(Node numeric, int startOffset, int length) { + public RationalNode(int startOffset, int length, short flags, Object numerator, Object denominator) { super(startOffset, length); - this.numeric = numeric; + this.flags = flags; + this.numerator = numerator; + this.denominator = denominator; } - + + public boolean isBinary() { + return IntegerBaseFlags.isBinary(flags); + } + + public boolean isDecimal() { + return IntegerBaseFlags.isDecimal(flags); + } + + public boolean isOctal() { + return IntegerBaseFlags.isOctal(flags); + } + + public boolean isHexadecimal() { + return IntegerBaseFlags.isHexadecimal(flags); + } + public void visitChildNodes(AbstractNodeVisitor visitor) { - this.numeric.accept(visitor); } public Node[] childNodes() { - return new Node[] { this.numeric }; + return EMPTY_ARRAY; } public T accept(AbstractNodeVisitor visitor) { @@ -8682,8 +9354,17 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("numeric: "); - builder.append(this.numeric.toString(nextIndent)); + builder.append("IntegerBaseFlags: "); + builder.append(flags); + builder.append('\n'); + builder.append(nextIndent); + builder.append("numerator: "); + builder.append(this.numerator); + builder.append('\n'); + builder.append(nextIndent); + builder.append("denominator: "); + builder.append(this.denominator); + builder.append('\n'); return builder.toString(); } } @@ -8738,54 +9419,54 @@ public static final class RegularExpressionNode extends Node { public final short flags; public final byte[] unescaped; - public RegularExpressionNode(short flags, byte[] unescaped, int startOffset, int length) { + public RegularExpressionNode(int startOffset, int length, short flags, byte[] unescaped) { super(startOffset, length); this.flags = flags; this.unescaped = unescaped; } public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(this.flags); + return RegularExpressionFlags.isIgnoreCase(flags); } public boolean isExtended() { - return RegularExpressionFlags.isExtended(this.flags); + return RegularExpressionFlags.isExtended(flags); } public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(this.flags); + return RegularExpressionFlags.isMultiLine(flags); } public boolean isOnce() { - return RegularExpressionFlags.isOnce(this.flags); + return RegularExpressionFlags.isOnce(flags); } public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(this.flags); + return RegularExpressionFlags.isEucJp(flags); } public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(this.flags); + return RegularExpressionFlags.isAscii8bit(flags); } public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(this.flags); + return RegularExpressionFlags.isWindows31j(flags); } public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(this.flags); + return RegularExpressionFlags.isUtf8(flags); } public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(this.flags); + return RegularExpressionFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(this.flags); + return RegularExpressionFlags.isForcedBinaryEncoding(flags); } public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(this.flags); + return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -8809,8 +9490,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("RegularExpressionFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("unescaped: "); @@ -8833,14 +9514,14 @@ public static final class RequiredKeywordParameterNode extends Node { public final short flags; public final org.jruby.RubySymbol name; - public RequiredKeywordParameterNode(short flags, org.jruby.RubySymbol name, int startOffset, int length) { + public RequiredKeywordParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { super(startOffset, length); this.flags = flags; this.name = name; } public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(this.flags); + return ParameterFlags.isRepeatedParameter(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -8864,8 +9545,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("ParameterFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("name: "); @@ -8888,14 +9569,14 @@ public static final class RequiredParameterNode extends Node { public final short flags; public final org.jruby.RubySymbol name; - public RequiredParameterNode(short flags, org.jruby.RubySymbol name, int startOffset, int length) { + public RequiredParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { super(startOffset, length); this.flags = flags; this.name = name; } public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(this.flags); + return ParameterFlags.isRepeatedParameter(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -8919,8 +9600,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("ParameterFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("name: "); @@ -8942,7 +9623,7 @@ public static final class RescueModifierNode extends Node { public final Node expression; public final Node rescue_expression; - public RescueModifierNode(Node expression, Node rescue_expression, int startOffset, int length) { + public RescueModifierNode(int startOffset, int length, Node expression, Node rescue_expression) { super(startOffset, length); this.expression = expression; this.rescue_expression = rescue_expression; @@ -8995,24 +9676,25 @@ protected String toString(String indent) { * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * end * - * `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `exception` field. + * `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field. * */ public static final class RescueNode extends Node { public final Node[] exceptions; @Nullable + @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class }) public final Node reference; @Nullable public final StatementsNode statements; @Nullable - public final RescueNode consequent; + public final RescueNode subsequent; - public RescueNode(Node[] exceptions, Node reference, StatementsNode statements, RescueNode consequent, int startOffset, int length) { + public RescueNode(int startOffset, int length, Node[] exceptions, Node reference, StatementsNode statements, RescueNode subsequent) { super(startOffset, length); this.exceptions = exceptions; this.reference = reference; this.statements = statements; - this.consequent = consequent; + this.subsequent = subsequent; } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -9025,8 +9707,8 @@ public void visitChildNodes(AbstractNodeVisitor visitor) { if (this.statements != null) { this.statements.accept(visitor); } - if (this.consequent != null) { - this.consequent.accept(visitor); + if (this.subsequent != null) { + this.subsequent.accept(visitor); } } @@ -9035,7 +9717,7 @@ public Node[] childNodes() { childNodes.addAll(Arrays.asList(this.exceptions)); childNodes.add(this.reference); childNodes.add(this.statements); - childNodes.add(this.consequent); + childNodes.add(this.subsequent); return childNodes.toArray(EMPTY_ARRAY); } @@ -9066,8 +9748,8 @@ protected String toString(String indent) { builder.append("statements: "); builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); builder.append(nextIndent); - builder.append("consequent: "); - builder.append(this.consequent == null ? "null\n" : this.consequent.toString(nextIndent)); + builder.append("subsequent: "); + builder.append(this.subsequent == null ? "null\n" : this.subsequent.toString(nextIndent)); return builder.toString(); } } @@ -9086,14 +9768,14 @@ public static final class RestParameterNode extends Node { @Nullable public final org.jruby.RubySymbol name; - public RestParameterNode(short flags, org.jruby.RubySymbol name, int startOffset, int length) { + public RestParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { super(startOffset, length); this.flags = flags; this.name = name; } public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(this.flags); + return ParameterFlags.isRepeatedParameter(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -9117,8 +9799,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("ParameterFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("name: "); @@ -9175,20 +9857,14 @@ protected String toString(String indent) { * */ public static final class ReturnNode extends Node { - public final short flags; @Nullable public final ArgumentsNode arguments; - public ReturnNode(short flags, ArgumentsNode arguments, int startOffset, int length) { + public ReturnNode(int startOffset, int length, ArgumentsNode arguments) { super(startOffset, length); - this.flags = flags; this.arguments = arguments; } - - public boolean isRedundant() { - return ReturnNodeFlags.isRedundant(this.flags); - } - + public void visitChildNodes(AbstractNodeVisitor visitor) { if (this.arguments != null) { this.arguments.accept(visitor); @@ -9213,10 +9889,6 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); - builder.append('\n'); - builder.append(nextIndent); builder.append("arguments: "); builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); return builder.toString(); @@ -9280,22 +9952,22 @@ public static final class ShareableConstantNode extends Node { @UnionType({ ConstantWriteNode.class, ConstantAndWriteNode.class, ConstantOrWriteNode.class, ConstantOperatorWriteNode.class, ConstantPathWriteNode.class, ConstantPathAndWriteNode.class, ConstantPathOrWriteNode.class, ConstantPathOperatorWriteNode.class }) public final Node write; - public ShareableConstantNode(short flags, Node write, int startOffset, int length) { + public ShareableConstantNode(int startOffset, int length, short flags, Node write) { super(startOffset, length); this.flags = flags; this.write = write; } public boolean isLiteral() { - return ShareableConstantNodeFlags.isLiteral(this.flags); + return ShareableConstantNodeFlags.isLiteral(flags); } public boolean isExperimentalEverything() { - return ShareableConstantNodeFlags.isExperimentalEverything(this.flags); + return ShareableConstantNodeFlags.isExperimentalEverything(flags); } public boolean isExperimentalCopy() { - return ShareableConstantNodeFlags.isExperimentalCopy(this.flags); + return ShareableConstantNodeFlags.isExperimentalCopy(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -9320,8 +9992,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("ShareableConstantNodeFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("write: "); @@ -9342,9 +10014,10 @@ public static final class SingletonClassNode extends Node { public final org.jruby.RubySymbol[] locals; public final Node expression; @Nullable + @UnionType({ StatementsNode.class, BeginNode.class }) public final Node body; - public SingletonClassNode(org.jruby.RubySymbol[] locals, Node expression, Node body, int startOffset, int length) { + public SingletonClassNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node expression, Node body) { super(startOffset, length); this.locals = locals; this.expression = expression; @@ -9447,26 +10120,26 @@ public static final class SourceFileNode extends Node { */ public final byte[] filepath; - public SourceFileNode(short flags, byte[] filepath, int startOffset, int length) { + public SourceFileNode(int startOffset, int length, short flags, byte[] filepath) { super(startOffset, length); this.flags = flags; this.filepath = filepath; } public boolean isForcedUtf8Encoding() { - return StringFlags.isForcedUtf8Encoding(this.flags); + return StringFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return StringFlags.isForcedBinaryEncoding(this.flags); + return StringFlags.isForcedBinaryEncoding(flags); } public boolean isFrozen() { - return StringFlags.isFrozen(this.flags); + return StringFlags.isFrozen(flags); } public boolean isMutable() { - return StringFlags.isMutable(this.flags); + return StringFlags.isMutable(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -9490,8 +10163,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("StringFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("filepath: "); @@ -9551,7 +10224,7 @@ public static final class SplatNode extends Node { @Nullable public final Node expression; - public SplatNode(Node expression, int startOffset, int length) { + public SplatNode(int startOffset, int length, Node expression) { super(startOffset, length); this.expression = expression; } @@ -9597,7 +10270,7 @@ protected String toString(String indent) { public static final class StatementsNode extends Node { public final Node[] body; - public StatementsNode(Node[] body, int startOffset, int length) { + public StatementsNode(int startOffset, int length, Node[] body) { super(startOffset, length); this.body = body; } @@ -9656,26 +10329,26 @@ public static final class StringNode extends Node { public final short flags; public final byte[] unescaped; - public StringNode(short flags, byte[] unescaped, int startOffset, int length) { + public StringNode(int startOffset, int length, short flags, byte[] unescaped) { super(startOffset, length); this.flags = flags; this.unescaped = unescaped; } public boolean isForcedUtf8Encoding() { - return StringFlags.isForcedUtf8Encoding(this.flags); + return StringFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return StringFlags.isForcedBinaryEncoding(this.flags); + return StringFlags.isForcedBinaryEncoding(flags); } public boolean isFrozen() { - return StringFlags.isFrozen(this.flags); + return StringFlags.isFrozen(flags); } public boolean isMutable() { - return StringFlags.isMutable(this.flags); + return StringFlags.isMutable(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -9699,8 +10372,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("StringFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("unescaped: "); @@ -9725,9 +10398,10 @@ public static final class SuperNode extends Node { @Nullable public final ArgumentsNode arguments; @Nullable + @UnionType({ BlockNode.class, BlockArgumentNode.class }) public final Node block; - public SuperNode(ArgumentsNode arguments, Node block, int startOffset, int length) { + public SuperNode(int startOffset, int length, ArgumentsNode arguments, Node block) { super(startOffset, length); this.arguments = arguments; this.block = block; @@ -9784,22 +10458,22 @@ public static final class SymbolNode extends Node { public final short flags; public final byte[] unescaped; - public SymbolNode(short flags, byte[] unescaped, int startOffset, int length) { + public SymbolNode(int startOffset, int length, short flags, byte[] unescaped) { super(startOffset, length); this.flags = flags; this.unescaped = unescaped; } public boolean isForcedUtf8Encoding() { - return SymbolFlags.isForcedUtf8Encoding(this.flags); + return SymbolFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return SymbolFlags.isForcedBinaryEncoding(this.flags); + return SymbolFlags.isForcedBinaryEncoding(flags); } public boolean isForcedUsAsciiEncoding() { - return SymbolFlags.isForcedUsAsciiEncoding(this.flags); + return SymbolFlags.isForcedUsAsciiEncoding(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -9823,8 +10497,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("SymbolFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("unescaped: "); @@ -9884,7 +10558,7 @@ public static final class UndefNode extends Node { @UnionType({ SymbolNode.class, InterpolatedSymbolNode.class }) public final Node[] names; - public UndefNode(Node[] names, int startOffset, int length) { + public UndefNode(int startOffset, int length, Node[] names) { super(startOffset, length); this.names = names; } @@ -9969,13 +10643,13 @@ public static final class UnlessNode extends Node { * */ @Nullable - public final ElseNode consequent; + public final ElseNode else_clause; - public UnlessNode(Node predicate, StatementsNode statements, ElseNode consequent, int startOffset, int length) { + public UnlessNode(int startOffset, int length, Node predicate, StatementsNode statements, ElseNode else_clause) { super(startOffset, length); this.predicate = predicate; this.statements = statements; - this.consequent = consequent; + this.else_clause = else_clause; } @Override @@ -9988,13 +10662,13 @@ public void visitChildNodes(AbstractNodeVisitor visitor) { if (this.statements != null) { this.statements.accept(visitor); } - if (this.consequent != null) { - this.consequent.accept(visitor); + if (this.else_clause != null) { + this.else_clause.accept(visitor); } } public Node[] childNodes() { - return new Node[] { this.predicate, this.statements, this.consequent }; + return new Node[] { this.predicate, this.statements, this.else_clause }; } public T accept(AbstractNodeVisitor visitor) { @@ -10017,8 +10691,8 @@ protected String toString(String indent) { builder.append("statements: "); builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); builder.append(nextIndent); - builder.append("consequent: "); - builder.append(this.consequent == null ? "null\n" : this.consequent.toString(nextIndent)); + builder.append("else_clause: "); + builder.append(this.else_clause == null ? "null\n" : this.else_clause.toString(nextIndent)); return builder.toString(); } } @@ -10040,7 +10714,7 @@ public static final class UntilNode extends Node { @Nullable public final StatementsNode statements; - public UntilNode(short flags, Node predicate, StatementsNode statements, int startOffset, int length) { + public UntilNode(int startOffset, int length, short flags, Node predicate, StatementsNode statements) { super(startOffset, length); this.flags = flags; this.predicate = predicate; @@ -10048,7 +10722,7 @@ public UntilNode(short flags, Node predicate, StatementsNode statements, int sta } public boolean isBeginModifier() { - return LoopFlags.isBeginModifier(this.flags); + return LoopFlags.isBeginModifier(flags); } @Override @@ -10081,8 +10755,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("LoopFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("predicate: "); @@ -10109,7 +10783,7 @@ public static final class WhenNode extends Node { @Nullable public final StatementsNode statements; - public WhenNode(Node[] conditions, StatementsNode statements, int startOffset, int length) { + public WhenNode(int startOffset, int length, Node[] conditions, StatementsNode statements) { super(startOffset, length); this.conditions = conditions; this.statements = statements; @@ -10175,7 +10849,7 @@ public static final class WhileNode extends Node { @Nullable public final StatementsNode statements; - public WhileNode(short flags, Node predicate, StatementsNode statements, int startOffset, int length) { + public WhileNode(int startOffset, int length, short flags, Node predicate, StatementsNode statements) { super(startOffset, length); this.flags = flags; this.predicate = predicate; @@ -10183,7 +10857,7 @@ public WhileNode(short flags, Node predicate, StatementsNode statements, int sta } public boolean isBeginModifier() { - return LoopFlags.isBeginModifier(this.flags); + return LoopFlags.isBeginModifier(flags); } @Override @@ -10216,8 +10890,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("LoopFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("predicate: "); @@ -10241,18 +10915,18 @@ public static final class XStringNode extends Node { public final short flags; public final byte[] unescaped; - public XStringNode(short flags, byte[] unescaped, int startOffset, int length) { + public XStringNode(int startOffset, int length, short flags, byte[] unescaped) { super(startOffset, length); this.flags = flags; this.unescaped = unescaped; } public boolean isForcedUtf8Encoding() { - return EncodingFlags.isForcedUtf8Encoding(this.flags); + return EncodingFlags.isForcedUtf8Encoding(flags); } public boolean isForcedBinaryEncoding() { - return EncodingFlags.isForcedBinaryEncoding(this.flags); + return EncodingFlags.isForcedBinaryEncoding(flags); } public void visitChildNodes(AbstractNodeVisitor visitor) { @@ -10276,8 +10950,8 @@ protected String toString(String indent) { builder.append('\n'); String nextIndent = indent + " "; builder.append(nextIndent); - builder.append("flags: "); - builder.append(this.flags); + builder.append("EncodingFlags: "); + builder.append(flags); builder.append('\n'); builder.append(nextIndent); builder.append("unescaped: "); @@ -10299,7 +10973,7 @@ public static final class YieldNode extends Node { @Nullable public final ArgumentsNode arguments; - public YieldNode(ArgumentsNode arguments, int startOffset, int length) { + public YieldNode(int startOffset, int length, ArgumentsNode arguments) { super(startOffset, length); this.arguments = arguments; } @@ -10351,7 +11025,6 @@ public enum ErrorType { ARGUMENT_FORMAL_GLOBAL, ARGUMENT_FORMAL_IVAR, ARGUMENT_FORWARDING_UNBOUND, - ARGUMENT_IN, ARGUMENT_NO_FORWARDING_AMPERSAND, ARGUMENT_NO_FORWARDING_ELLIPSES, ARGUMENT_NO_FORWARDING_STAR, @@ -10417,8 +11090,10 @@ public enum ErrorType { ESCAPE_INVALID_META_REPEAT, ESCAPE_INVALID_UNICODE, ESCAPE_INVALID_UNICODE_CM_FLAGS, + ESCAPE_INVALID_UNICODE_LIST, ESCAPE_INVALID_UNICODE_LITERAL, ESCAPE_INVALID_UNICODE_LONG, + ESCAPE_INVALID_UNICODE_SHORT, ESCAPE_INVALID_UNICODE_TERM, EXPECT_ARGUMENT, EXPECT_EOL_AFTER_STATEMENT, @@ -10433,6 +11108,7 @@ public enum ErrorType { EXPECT_EXPRESSION_AFTER_SPLAT, EXPECT_EXPRESSION_AFTER_SPLAT_HASH, EXPECT_EXPRESSION_AFTER_STAR, + EXPECT_FOR_DELIMITER, EXPECT_IDENT_REQ_PARAMETER, EXPECT_IN_DELIMITER, EXPECT_LPAREN_REQ_PARAMETER, @@ -10441,6 +11117,7 @@ public enum ErrorType { EXPECT_RPAREN, EXPECT_RPAREN_AFTER_MULTI, EXPECT_RPAREN_REQ_PARAMETER, + EXPECT_SINGLETON_CLASS_DELIMITER, EXPECT_STRING_CONTENT, EXPECT_WHEN_DELIMITER, EXPRESSION_BARE_HASH, @@ -10450,6 +11127,7 @@ public enum ErrorType { EXPRESSION_NOT_WRITABLE_FILE, EXPRESSION_NOT_WRITABLE_LINE, EXPRESSION_NOT_WRITABLE_NIL, + EXPRESSION_NOT_WRITABLE_NUMBERED, EXPRESSION_NOT_WRITABLE_SELF, EXPRESSION_NOT_WRITABLE_TRUE, FLOAT_PARSE, @@ -10473,6 +11151,7 @@ public enum ErrorType { INSTANCE_VARIABLE_BARE, INVALID_BLOCK_EXIT, INVALID_CHARACTER, + INVALID_COMMA, INVALID_ENCODING_MAGIC_COMMENT, INVALID_ESCAPE_CHARACTER, INVALID_FLOAT_EXPONENT, @@ -10489,6 +11168,7 @@ public enum ErrorType { INVALID_NUMBER_UNDERSCORE_INNER, INVALID_NUMBER_UNDERSCORE_TRAILING, INVALID_PERCENT, + INVALID_PERCENT_EOF, INVALID_PRINTABLE_CHARACTER, INVALID_RETRY_AFTER_ELSE, INVALID_RETRY_AFTER_ENSURE, @@ -10517,12 +11197,15 @@ public enum ErrorType { MODULE_TERM, MULTI_ASSIGN_MULTI_SPLATS, MULTI_ASSIGN_UNEXPECTED_REST, + NESTING_TOO_DEEP, NO_LOCAL_VARIABLE, + NON_ASSOCIATIVE_OPERATOR, NOT_EXPRESSION, NUMBER_LITERAL_UNDERSCORE, + NUMBERED_PARAMETER_INNER_BLOCK, NUMBERED_PARAMETER_IT, NUMBERED_PARAMETER_ORDINARY, - NUMBERED_PARAMETER_OUTER_SCOPE, + NUMBERED_PARAMETER_OUTER_BLOCK, OPERATOR_MULTI_ASSIGN, OPERATOR_WRITE_ARGUMENTS, OPERATOR_WRITE_BLOCK, @@ -10539,8 +11222,9 @@ public enum ErrorType { PARAMETER_SPLAT_MULTI, PARAMETER_STAR, PARAMETER_UNEXPECTED_FWD, - PARAMETER_WILD_LOOSE_COMMA, PARAMETER_UNEXPECTED_NO_KW, + PARAMETER_WILD_LOOSE_COMMA, + PATTERN_ARRAY_MULTIPLE_RESTS, PATTERN_CAPTURE_DUPLICATE, PATTERN_EXPRESSION_AFTER_BRACKET, PATTERN_EXPRESSION_AFTER_COMMA, @@ -10552,6 +11236,7 @@ public enum ErrorType { PATTERN_EXPRESSION_AFTER_PIPE, PATTERN_EXPRESSION_AFTER_RANGE, PATTERN_EXPRESSION_AFTER_REST, + PATTERN_FIND_MISSING_INNER, PATTERN_HASH_IMPLICIT, PATTERN_HASH_KEY, PATTERN_HASH_KEY_DUPLICATE, @@ -10569,6 +11254,7 @@ public enum ErrorType { REGEXP_INCOMPAT_CHAR_ENCODING, REGEXP_INVALID_UNICODE_RANGE, REGEXP_NON_ESCAPED_MBC, + REGEXP_PARSE_ERROR, REGEXP_TERM, REGEXP_UNKNOWN_OPTIONS, REGEXP_UTF8_CHAR_NON_UTF8_REGEXP, @@ -10593,11 +11279,15 @@ public enum ErrorType { TERNARY_COLON, TERNARY_EXPRESSION_FALSE, TERNARY_EXPRESSION_TRUE, + UNARY_DISALLOWED, UNARY_RECEIVER, UNDEF_ARGUMENT, UNEXPECTED_BLOCK_ARGUMENT, UNEXPECTED_INDEX_BLOCK, UNEXPECTED_INDEX_KEYWORDS, + UNEXPECTED_LABEL, + UNEXPECTED_MULTI_WRITE, + UNEXPECTED_RANGE_OPERATOR, UNEXPECTED_SAFE_NAVIGATION, UNEXPECTED_TOKEN_CLOSE_CONTEXT, UNEXPECTED_TOKEN_IGNORE, @@ -10613,6 +11303,7 @@ public enum ErrorType { public static ErrorType[] ERROR_TYPES = ErrorType.values(); public enum WarningType { + AMBIGUOUS_BINARY_OPERATOR, AMBIGUOUS_FIRST_ARGUMENT_MINUS, AMBIGUOUS_FIRST_ARGUMENT_PLUS, AMBIGUOUS_PREFIX_AMPERSAND, @@ -10628,10 +11319,11 @@ public enum WarningType { DUPLICATED_WHEN_CLAUSE, FLOAT_OUT_OF_RANGE, IGNORED_FROZEN_STRING_LITERAL, + INDENTATION_MISMATCH, INTEGER_IN_FLIP_FLOP, INVALID_CHARACTER, + INVALID_MAGIC_COMMENT_VALUE, INVALID_NUMBERED_REFERENCE, - INVALID_SHAREABLE_CONSTANT_VALUE, KEYWORD_EOL, LITERAL_IN_CONDITION_DEFAULT, LITERAL_IN_CONDITION_VERBOSE, diff --git a/src/main/java/org/prism/Parser.java b/src/main/java/org/prism/Parser.java index ec51883..717c3e5 100644 --- a/src/main/java/org/prism/Parser.java +++ b/src/main/java/org/prism/Parser.java @@ -2,6 +2,7 @@ public abstract class Parser { + @SuppressWarnings("restricted") public static void loadLibrary(String path) { System.load(path); } diff --git a/src/main/java/org/prism/ParsingOptions.java b/src/main/java/org/prism/ParsingOptions.java index 598b07a..ff2e995 100644 --- a/src/main/java/org/prism/ParsingOptions.java +++ b/src/main/java/org/prism/ParsingOptions.java @@ -13,7 +13,8 @@ public abstract class ParsingOptions { */ public enum SyntaxVersion { LATEST(0), - V3_3(1); + V3_3(1), + V3_4(2); private final int value; @@ -34,6 +35,69 @@ public byte getValue() { */ public enum CommandLine { A, E, L, N, P, X }; + /** + * The forwarding options for a given scope in the parser. + */ + public enum Forwarding { + NONE(0), + POSITIONAL(1), + KEYWORD(2), + BLOCK(4), + ALL(8); + + private final int value; + + Forwarding(int value) { + this.value = value; + } + + public byte getValue() { + return (byte) value; + } + }; + + /** + * Represents a scope in the parser. + */ + public static class Scope { + private byte[][] locals; + private Forwarding[] forwarding; + + Scope(byte[][] locals) { + this(locals, new Forwarding[0]); + } + + Scope(Forwarding[] forwarding) { + this(new byte[0][], forwarding); + } + + Scope(byte[][] locals, Forwarding[] forwarding) { + this.locals = locals; + this.forwarding = forwarding; + } + + public byte[][] getLocals() { + return locals; + } + + public int getForwarding() { + int value = 0; + for (Forwarding f : forwarding) { + value |= f.getValue(); + } + return value; + } + } + + public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boolean frozenStringLiteral, EnumSet commandLine, SyntaxVersion version, boolean encodingLocked, boolean mainScript, boolean partialScript, byte[][][] scopes) { + Scope[] normalizedScopes = new Scope[scopes.length]; + for (int i = 0; i < scopes.length; i++) { + normalizedScopes[i] = new Scope(scopes[i]); + } + + return serialize(filepath, line, encoding, frozenStringLiteral, commandLine, version, encodingLocked, mainScript, partialScript, normalizedScopes); + } + /** * Serialize parsing options into byte array. * @@ -43,10 +107,13 @@ public enum CommandLine { A, E, L, N, P, X }; * @param frozenStringLiteral whether the frozen string literal option has been set * @param commandLine the set of flags that were set on the command line * @param version code of Ruby version which syntax will be used to parse + * @param encodingLocked whether the encoding is locked (should almost always be false) + * @param mainScript whether the file is the main script + * @param partialScript whether the file is a partial script * @param scopes scopes surrounding the code that is being parsed with local variable names defined in every scope * ordered from the outermost scope to the innermost one */ - public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boolean frozenStringLiteral, EnumSet commandLine, SyntaxVersion version, byte[][][] scopes) { + public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boolean frozenStringLiteral, EnumSet commandLine, SyntaxVersion version, boolean encodingLocked, boolean mainScript, boolean partialScript, Scope[] scopes) { final ByteArrayOutputStream output = new ByteArrayOutputStream(); // filepath @@ -69,17 +136,35 @@ public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boole // version output.write(version.getValue()); + // encodingLocked + output.write(encodingLocked ? 1 : 0); + + // mainScript + output.write(mainScript ? 1 : 0); + + // partialScript + output.write(partialScript ? 1 : 0); + + // freeze + output.write(0); + // scopes // number of scopes write(output, serializeInt(scopes.length)); + // local variables in each scope - for (byte[][] scope : scopes) { + for (Scope scope : scopes) { + byte[][] locals = scope.getLocals(); + // number of locals - write(output, serializeInt(scope.length)); + write(output, serializeInt(locals.length)); + + // forwarding flags + output.write(scope.getForwarding()); // locals - for (byte[] local : scope) { + for (byte[] local : locals) { write(output, serializeInt(local.length)); write(output, local); } From 959f954543879f17ae21f60834facadd24bcc18c Mon Sep 17 00:00:00 2001 From: "Thomas E. Enebo" Date: Wed, 21 Jan 2026 14:50:54 -0600 Subject: [PATCH 02/21] Dumping incomplete state but it has some chicory stuff in it --- pom.xml | 27 +- .../jruby/prism/builder/IRBuilderPrism.java | 19 +- .../org/jruby/prism/parser/ParserPrism.java | 47 +- .../java/org/prism/AbstractNodeVisitor.java | 1528 --- src/main/java/org/prism/Loader.java | 775 -- .../java/org/prism/MarkNewlinesVisitor.java | 62 - src/main/java/org/prism/Nodes.java | 11340 ---------------- src/main/java/org/prism/ParseResult.java | 83 - src/main/java/org/prism/Parser.java | 16 - src/main/java/org/prism/ParsingOptions.java | 196 - 10 files changed, 53 insertions(+), 14040 deletions(-) delete mode 100644 src/main/java/org/prism/AbstractNodeVisitor.java delete mode 100644 src/main/java/org/prism/Loader.java delete mode 100644 src/main/java/org/prism/MarkNewlinesVisitor.java delete mode 100644 src/main/java/org/prism/Nodes.java delete mode 100644 src/main/java/org/prism/ParseResult.java delete mode 100644 src/main/java/org/prism/Parser.java delete mode 100644 src/main/java/org/prism/ParsingOptions.java diff --git a/pom.xml b/pom.xml index 7158f70..c9b7c93 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ org.jruby jruby-prism jar - 1.4.0 + 1.5.0 jruby-prism Java portion of JRuby Prism parser support. @@ -12,8 +12,10 @@ UTF-8 - 21 - 21 + 1.2.1 + 5.12.1 + 17 + 17 @@ -48,6 +50,18 @@ + + + + com.dylibso.chicory + bom + ${chicory.version} + pom + import + + + + org.jruby @@ -55,10 +69,9 @@ 10.0.0.0-SNAPSHOT - junit - junit - 4.13.1 - test + com.prism + java-prism + 999-SNAPSHOT diff --git a/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java b/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java index 1a39a7f..2dc9172 100644 --- a/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java +++ b/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java @@ -731,10 +731,13 @@ private Operand buildCall(Variable resultArg, CallNode node, RubySymbol name, La } } + boolean reusingLabels = false; if (node.isSafeNavigation()) { if (lazyLabel == null) { lazyLabel = getNewLabel(); endLabel = getNewLabel(); + } else { + reusingLabels = true; } } @@ -758,9 +761,11 @@ private Operand buildCall(Variable resultArg, CallNode node, RubySymbol name, La if (node.isSafeNavigation()) { addInstr(new JumpInstr(endLabel)); - addInstr(new LabelInstr(lazyLabel)); - addInstr(new CopyInstr(result, nil())); - addInstr(new LabelInstr(endLabel)); + if (!reusingLabels) { // This already exists. + addInstr(new LabelInstr(lazyLabel)); + addInstr(new CopyInstr(result, nil())); + addInstr(new LabelInstr(endLabel)); + } } return result; @@ -1366,10 +1371,10 @@ private Operand buildHash(Node[] elements, boolean hasAssignments) { if (!keysHack.add(hack)) getManager().getRuntime().getWarnings().warn("key :" + hack + " is duplicated and overwritten on line " + (getLine(key) + 1)); } else if (keyOperand instanceof Fixnum) { long hack = ((Fixnum) keyOperand).value; - if (!keysHack.add(new Long(hack))) getManager().getRuntime().getWarnings().warn("key " + hack + " is duplicated and overwritten on line " + (getLine(key) + 1)); + if (!keysHack.add(Long.valueOf(hack))) getManager().getRuntime().getWarnings().warn("key " + hack + " is duplicated and overwritten on line " + (getLine(key) + 1)); } else if (keyOperand instanceof Float) { double hack = ((Float) keyOperand).value; - if (!keysHack.add(new Double(hack))) getManager().getRuntime().getWarnings().warn("key " + hack + " is duplicated and overwritten on line " + (getLine(key) + 1)); + if (!keysHack.add(Double.valueOf(hack))) getManager().getRuntime().getWarnings().warn("key " + hack + " is duplicated and overwritten on line " + (getLine(key) + 1)); } } args.add(new KeyValuePair<>(keyOperand, buildWithOrder(((AssocNode) pair).value, hasAssignments))); @@ -1470,7 +1475,7 @@ protected Operand buildDRegex(Variable result, Node[] children, RegexpOptions op // value of the regexp. Adding an empty string will pick up the encoding from options (this // empty string is how legacy parsers do this but it naturally falls out of the parser. pieces = new Node[children.length + 1]; - pieces[0] = new StringNode(0, 0, (short) 0, EMPTY.bytes()); + pieces[0] = new StringNode(-1, 0, 0, (short) 0, EMPTY.bytes()); pieces[1] = children[0]; } else { pieces = children; @@ -1603,7 +1608,7 @@ private Operand buildMatchPredicate(MatchPredicateNode node) { } private Operand buildMatchRequired(MatchRequiredNode node) { - return buildPatternCase(node.value, new Node[] { new InNode(0, 0, node.pattern, null) }, null); + return buildPatternCase(node.value, new Node[] { new InNode(-1, 0, 0, node.pattern, null) }, null); } private Operand buildMatchWrite(Variable result, MatchWriteNode node) { diff --git a/src/main/java/org/jruby/prism/parser/ParserPrism.java b/src/main/java/org/jruby/prism/parser/ParserPrism.java index def8f7c..f11dee3 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrism.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrism.java @@ -11,6 +11,7 @@ import org.jruby.ext.coverage.CoverageData; import org.jruby.management.ParserStats; import org.jruby.parser.Parser; +import org.jruby.parser.ParserManager; import org.jruby.parser.ParserType; import org.jruby.parser.StaticScope; import org.jruby.runtime.DynamicScope; @@ -23,6 +24,7 @@ import org.prism.Nodes; import org.prism.Nodes.*; import org.prism.ParsingOptions; +import org.prism.Prism; import java.io.ByteArrayInputStream; import java.io.DataInputStream; @@ -32,6 +34,7 @@ import java.util.Arrays; import java.util.List; +import static org.jruby.api.Convert.asSymbol; import static org.jruby.lexer.LexingCommon.DOLLAR_UNDERSCORE; import static org.jruby.parser.ParserType.EVAL; import static org.jruby.parser.ParserType.MAIN; @@ -173,7 +176,7 @@ private byte[] loadFully(String fileName, InputStream in) { private byte[] parse(byte[] source, int sourceLength, byte[] metadata) { -// if (ParserManager.PARSER_WASM) return parseChicory(source, sourceLength, metadata); + if (ParserManager.PARSER_WASM) return parseChicory(source, sourceLength, metadata); long time = 0; if (parserTiming) time = System.nanoTime(); @@ -194,21 +197,12 @@ private byte[] parse(byte[] source, int sourceLength, byte[] metadata) { return src; } - /* - private byte[] parseChicory(byte[] source, int sourceLength, byte[] metadata) { - long time = 0; - if (parserTiming) time = System.nanoTime(); - - byte[] serialized = prismWasmWrapper.parse(source, sourceLength, metadata); - - if (parserTiming) { - ParserStats stats = runtime.getParserManager().getParserStats(); - stats.addYARPTimeCParseSerialize(System.nanoTime() - time); + private byte[] parseChicory(byte[] source, int sourceLength, byte[] metadata) { + try (Prism prism = new Prism()) { + return prism.serialize(metadata, source, sourceLength); } - - return serialized; - }*/ + } // lineNumber (0-indexed) private byte[] generateMetadata(String fileName, int lineNumber, Encoding encoding, DynamicScope scope, ParserType type) { @@ -332,42 +326,43 @@ public IRubyObject getLineStub(ThreadContext context, ParseResult arg, int lineC // show it happening on line 1 (which is what it should do). @Override public ParseResult addGetsLoop(Ruby runtime, ParseResult result, boolean printing, boolean processLineEndings, boolean split) { + var context = runtime.getCurrentContext(); List newBody = new ArrayList<>(); if (processLineEndings) { - newBody.add(new Nodes.GlobalVariableWriteNode(0, 0, runtime.newSymbol(CommonByteLists.DOLLAR_BACKSLASH), - new GlobalVariableReadNode(0, 0, runtime.newSymbol(CommonByteLists.DOLLAR_SLASH)))); + newBody.add(new Nodes.GlobalVariableWriteNode(-1, 0, 0, asSymbol(context, CommonByteLists.DOLLAR_BACKSLASH), + new GlobalVariableReadNode(-1, 0, 0, asSymbol(context, CommonByteLists.DOLLAR_SLASH)))); } - Nodes.GlobalVariableReadNode dollarUnderscore = new GlobalVariableReadNode(0, 0, runtime.newSymbol(DOLLAR_UNDERSCORE)); + Nodes.GlobalVariableReadNode dollarUnderscore = new GlobalVariableReadNode(-1, 0, 0, asSymbol(context, DOLLAR_UNDERSCORE)); List whileBody = new ArrayList<>(); if (processLineEndings) { - whileBody.add(new CallNode(0, 0, (short) 0, dollarUnderscore, runtime.newSymbol("chomp!"), null, null)); + whileBody.add(new CallNode(-1, 0, 0, (short) 0, dollarUnderscore, asSymbol(context, "chomp!"), null, null)); } if (split) { - whileBody.add(new GlobalVariableWriteNode(0, 0, runtime.newSymbol("$F"), - new Nodes.CallNode(0, 0, (short) 0, dollarUnderscore, runtime.newSymbol("split"), null, null))); + whileBody.add(new GlobalVariableWriteNode(-1, 0, 0, asSymbol(context, "$F"), + new Nodes.CallNode(-1, 0, 0, (short) 0, dollarUnderscore, asSymbol(context, "split"), null, null))); } StatementsNode stmts = ((ProgramNode) result.getAST()).statements; if (stmts != null && stmts.body != null) whileBody.addAll(Arrays.asList(stmts.body)); - ArgumentsNode args = new ArgumentsNode(0, 0, (short) 0, new Node[] { dollarUnderscore }); - if (printing) whileBody.add(new CallNode(0, 0, (short) 0, null, runtime.newSymbol("print"), args, null)); + ArgumentsNode args = new ArgumentsNode(-1, 0, 0, (short) 0, new Node[] { dollarUnderscore }); + if (printing) whileBody.add(new CallNode(-1, 0, 0, (short) 0, null, asSymbol(context, "print"), args, null)); Node[] nodes = new Node[whileBody.size()]; whileBody.toArray(nodes); - StatementsNode statements = new StatementsNode(0, 0, nodes); + StatementsNode statements = new StatementsNode(-1, 0, 0, nodes); - newBody.add(new WhileNode(0, 0, (short) 0, - new CallNode(0, 0, CallNodeFlags.VARIABLE_CALL, null, runtime.newSymbol("gets"), null, null), + newBody.add(new WhileNode(-1, 0, 0, (short) 0, + new CallNode(-1, 0, 0, CallNodeFlags.VARIABLE_CALL, null, asSymbol(context, "gets"), null, null), statements)); nodes = new Node[newBody.size()]; newBody.toArray(nodes); - Nodes.ProgramNode newRoot = new Nodes.ProgramNode(0, 0, new RubySymbol[] {}, new StatementsNode(0, 0, nodes)); + Nodes.ProgramNode newRoot = new Nodes.ProgramNode(-1, 0, 0, new RubySymbol[] {}, new StatementsNode(-1, 0, 0, nodes)); ((ParseResultPrism) result).setRoot(newRoot); diff --git a/src/main/java/org/prism/AbstractNodeVisitor.java b/src/main/java/org/prism/AbstractNodeVisitor.java deleted file mode 100644 index bad1c32..0000000 --- a/src/main/java/org/prism/AbstractNodeVisitor.java +++ /dev/null @@ -1,1528 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* This file is generated by the templates/template.rb script and should not */ -/* be modified manually. See */ -/* templates/java/org/prism/AbstractNodeVisitor.java.erb */ -/* if you are looking to modify the */ -/* template */ -/*----------------------------------------------------------------------------*/ - -package org.prism; - -// GENERATED BY AbstractNodeVisitor.java.erb -// @formatter:off -public abstract class AbstractNodeVisitor { - - protected abstract T defaultVisit(Nodes.Node node); - - /** - * Visit a AliasGlobalVariableNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitAliasGlobalVariableNode(Nodes.AliasGlobalVariableNode node) { - return defaultVisit(node); - } - - /** - * Visit a AliasMethodNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitAliasMethodNode(Nodes.AliasMethodNode node) { - return defaultVisit(node); - } - - /** - * Visit a AlternationPatternNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitAlternationPatternNode(Nodes.AlternationPatternNode node) { - return defaultVisit(node); - } - - /** - * Visit a AndNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitAndNode(Nodes.AndNode node) { - return defaultVisit(node); - } - - /** - * Visit a ArgumentsNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitArgumentsNode(Nodes.ArgumentsNode node) { - return defaultVisit(node); - } - - /** - * Visit a ArrayNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitArrayNode(Nodes.ArrayNode node) { - return defaultVisit(node); - } - - /** - * Visit a ArrayPatternNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitArrayPatternNode(Nodes.ArrayPatternNode node) { - return defaultVisit(node); - } - - /** - * Visit a AssocNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitAssocNode(Nodes.AssocNode node) { - return defaultVisit(node); - } - - /** - * Visit a AssocSplatNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitAssocSplatNode(Nodes.AssocSplatNode node) { - return defaultVisit(node); - } - - /** - * Visit a BackReferenceReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBackReferenceReadNode(Nodes.BackReferenceReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a BeginNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBeginNode(Nodes.BeginNode node) { - return defaultVisit(node); - } - - /** - * Visit a BlockArgumentNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBlockArgumentNode(Nodes.BlockArgumentNode node) { - return defaultVisit(node); - } - - /** - * Visit a BlockLocalVariableNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBlockLocalVariableNode(Nodes.BlockLocalVariableNode node) { - return defaultVisit(node); - } - - /** - * Visit a BlockNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBlockNode(Nodes.BlockNode node) { - return defaultVisit(node); - } - - /** - * Visit a BlockParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBlockParameterNode(Nodes.BlockParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a BlockParametersNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBlockParametersNode(Nodes.BlockParametersNode node) { - return defaultVisit(node); - } - - /** - * Visit a BreakNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitBreakNode(Nodes.BreakNode node) { - return defaultVisit(node); - } - - /** - * Visit a CallAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCallAndWriteNode(Nodes.CallAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a CallNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCallNode(Nodes.CallNode node) { - return defaultVisit(node); - } - - /** - * Visit a CallOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCallOperatorWriteNode(Nodes.CallOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a CallOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCallOrWriteNode(Nodes.CallOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a CallTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCallTargetNode(Nodes.CallTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a CapturePatternNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCapturePatternNode(Nodes.CapturePatternNode node) { - return defaultVisit(node); - } - - /** - * Visit a CaseMatchNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCaseMatchNode(Nodes.CaseMatchNode node) { - return defaultVisit(node); - } - - /** - * Visit a CaseNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitCaseNode(Nodes.CaseNode node) { - return defaultVisit(node); - } - - /** - * Visit a ClassNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitClassNode(Nodes.ClassNode node) { - return defaultVisit(node); - } - - /** - * Visit a ClassVariableAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitClassVariableAndWriteNode(Nodes.ClassVariableAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ClassVariableOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitClassVariableOperatorWriteNode(Nodes.ClassVariableOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ClassVariableOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitClassVariableOrWriteNode(Nodes.ClassVariableOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ClassVariableReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitClassVariableReadNode(Nodes.ClassVariableReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a ClassVariableTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitClassVariableTargetNode(Nodes.ClassVariableTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a ClassVariableWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitClassVariableWriteNode(Nodes.ClassVariableWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantAndWriteNode(Nodes.ConstantAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantOperatorWriteNode(Nodes.ConstantOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantOrWriteNode(Nodes.ConstantOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantPathAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantPathAndWriteNode(Nodes.ConstantPathAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantPathNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantPathNode(Nodes.ConstantPathNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantPathOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantPathOperatorWriteNode(Nodes.ConstantPathOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantPathOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantPathOrWriteNode(Nodes.ConstantPathOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantPathTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantPathTargetNode(Nodes.ConstantPathTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantPathWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantPathWriteNode(Nodes.ConstantPathWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantReadNode(Nodes.ConstantReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantTargetNode(Nodes.ConstantTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a ConstantWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitConstantWriteNode(Nodes.ConstantWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a DefNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitDefNode(Nodes.DefNode node) { - return defaultVisit(node); - } - - /** - * Visit a DefinedNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitDefinedNode(Nodes.DefinedNode node) { - return defaultVisit(node); - } - - /** - * Visit a ElseNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitElseNode(Nodes.ElseNode node) { - return defaultVisit(node); - } - - /** - * Visit a EmbeddedStatementsNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitEmbeddedStatementsNode(Nodes.EmbeddedStatementsNode node) { - return defaultVisit(node); - } - - /** - * Visit a EmbeddedVariableNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitEmbeddedVariableNode(Nodes.EmbeddedVariableNode node) { - return defaultVisit(node); - } - - /** - * Visit a EnsureNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitEnsureNode(Nodes.EnsureNode node) { - return defaultVisit(node); - } - - /** - * Visit a FalseNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitFalseNode(Nodes.FalseNode node) { - return defaultVisit(node); - } - - /** - * Visit a FindPatternNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitFindPatternNode(Nodes.FindPatternNode node) { - return defaultVisit(node); - } - - /** - * Visit a FlipFlopNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitFlipFlopNode(Nodes.FlipFlopNode node) { - return defaultVisit(node); - } - - /** - * Visit a FloatNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitFloatNode(Nodes.FloatNode node) { - return defaultVisit(node); - } - - /** - * Visit a ForNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitForNode(Nodes.ForNode node) { - return defaultVisit(node); - } - - /** - * Visit a ForwardingArgumentsNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitForwardingArgumentsNode(Nodes.ForwardingArgumentsNode node) { - return defaultVisit(node); - } - - /** - * Visit a ForwardingParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitForwardingParameterNode(Nodes.ForwardingParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a ForwardingSuperNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitForwardingSuperNode(Nodes.ForwardingSuperNode node) { - return defaultVisit(node); - } - - /** - * Visit a GlobalVariableAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitGlobalVariableAndWriteNode(Nodes.GlobalVariableAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a GlobalVariableOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitGlobalVariableOperatorWriteNode(Nodes.GlobalVariableOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a GlobalVariableOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitGlobalVariableOrWriteNode(Nodes.GlobalVariableOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a GlobalVariableReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitGlobalVariableReadNode(Nodes.GlobalVariableReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a GlobalVariableTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitGlobalVariableTargetNode(Nodes.GlobalVariableTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a GlobalVariableWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitGlobalVariableWriteNode(Nodes.GlobalVariableWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a HashNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitHashNode(Nodes.HashNode node) { - return defaultVisit(node); - } - - /** - * Visit a HashPatternNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitHashPatternNode(Nodes.HashPatternNode node) { - return defaultVisit(node); - } - - /** - * Visit a IfNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitIfNode(Nodes.IfNode node) { - return defaultVisit(node); - } - - /** - * Visit a ImaginaryNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitImaginaryNode(Nodes.ImaginaryNode node) { - return defaultVisit(node); - } - - /** - * Visit a ImplicitNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitImplicitNode(Nodes.ImplicitNode node) { - return defaultVisit(node); - } - - /** - * Visit a ImplicitRestNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitImplicitRestNode(Nodes.ImplicitRestNode node) { - return defaultVisit(node); - } - - /** - * Visit a InNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInNode(Nodes.InNode node) { - return defaultVisit(node); - } - - /** - * Visit a IndexAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitIndexAndWriteNode(Nodes.IndexAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a IndexOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitIndexOperatorWriteNode(Nodes.IndexOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a IndexOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitIndexOrWriteNode(Nodes.IndexOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a IndexTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitIndexTargetNode(Nodes.IndexTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a InstanceVariableAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInstanceVariableAndWriteNode(Nodes.InstanceVariableAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a InstanceVariableOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInstanceVariableOperatorWriteNode(Nodes.InstanceVariableOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a InstanceVariableOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInstanceVariableOrWriteNode(Nodes.InstanceVariableOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a InstanceVariableReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInstanceVariableReadNode(Nodes.InstanceVariableReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a InstanceVariableTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInstanceVariableTargetNode(Nodes.InstanceVariableTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a InstanceVariableWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInstanceVariableWriteNode(Nodes.InstanceVariableWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a IntegerNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitIntegerNode(Nodes.IntegerNode node) { - return defaultVisit(node); - } - - /** - * Visit a InterpolatedMatchLastLineNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInterpolatedMatchLastLineNode(Nodes.InterpolatedMatchLastLineNode node) { - return defaultVisit(node); - } - - /** - * Visit a InterpolatedRegularExpressionNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInterpolatedRegularExpressionNode(Nodes.InterpolatedRegularExpressionNode node) { - return defaultVisit(node); - } - - /** - * Visit a InterpolatedStringNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInterpolatedStringNode(Nodes.InterpolatedStringNode node) { - return defaultVisit(node); - } - - /** - * Visit a InterpolatedSymbolNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInterpolatedSymbolNode(Nodes.InterpolatedSymbolNode node) { - return defaultVisit(node); - } - - /** - * Visit a InterpolatedXStringNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitInterpolatedXStringNode(Nodes.InterpolatedXStringNode node) { - return defaultVisit(node); - } - - /** - * Visit a ItLocalVariableReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitItLocalVariableReadNode(Nodes.ItLocalVariableReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a ItParametersNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitItParametersNode(Nodes.ItParametersNode node) { - return defaultVisit(node); - } - - /** - * Visit a KeywordHashNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitKeywordHashNode(Nodes.KeywordHashNode node) { - return defaultVisit(node); - } - - /** - * Visit a KeywordRestParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitKeywordRestParameterNode(Nodes.KeywordRestParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a LambdaNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitLambdaNode(Nodes.LambdaNode node) { - return defaultVisit(node); - } - - /** - * Visit a LocalVariableAndWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitLocalVariableAndWriteNode(Nodes.LocalVariableAndWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a LocalVariableOperatorWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitLocalVariableOperatorWriteNode(Nodes.LocalVariableOperatorWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a LocalVariableOrWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitLocalVariableOrWriteNode(Nodes.LocalVariableOrWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a LocalVariableReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitLocalVariableReadNode(Nodes.LocalVariableReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a LocalVariableTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitLocalVariableTargetNode(Nodes.LocalVariableTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a LocalVariableWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitLocalVariableWriteNode(Nodes.LocalVariableWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a MatchLastLineNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitMatchLastLineNode(Nodes.MatchLastLineNode node) { - return defaultVisit(node); - } - - /** - * Visit a MatchPredicateNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitMatchPredicateNode(Nodes.MatchPredicateNode node) { - return defaultVisit(node); - } - - /** - * Visit a MatchRequiredNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitMatchRequiredNode(Nodes.MatchRequiredNode node) { - return defaultVisit(node); - } - - /** - * Visit a MatchWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitMatchWriteNode(Nodes.MatchWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a MissingNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitMissingNode(Nodes.MissingNode node) { - return defaultVisit(node); - } - - /** - * Visit a ModuleNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitModuleNode(Nodes.ModuleNode node) { - return defaultVisit(node); - } - - /** - * Visit a MultiTargetNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitMultiTargetNode(Nodes.MultiTargetNode node) { - return defaultVisit(node); - } - - /** - * Visit a MultiWriteNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitMultiWriteNode(Nodes.MultiWriteNode node) { - return defaultVisit(node); - } - - /** - * Visit a NextNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitNextNode(Nodes.NextNode node) { - return defaultVisit(node); - } - - /** - * Visit a NilNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitNilNode(Nodes.NilNode node) { - return defaultVisit(node); - } - - /** - * Visit a NoKeywordsParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitNoKeywordsParameterNode(Nodes.NoKeywordsParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a NumberedParametersNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitNumberedParametersNode(Nodes.NumberedParametersNode node) { - return defaultVisit(node); - } - - /** - * Visit a NumberedReferenceReadNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitNumberedReferenceReadNode(Nodes.NumberedReferenceReadNode node) { - return defaultVisit(node); - } - - /** - * Visit a OptionalKeywordParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitOptionalKeywordParameterNode(Nodes.OptionalKeywordParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a OptionalParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitOptionalParameterNode(Nodes.OptionalParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a OrNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitOrNode(Nodes.OrNode node) { - return defaultVisit(node); - } - - /** - * Visit a ParametersNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitParametersNode(Nodes.ParametersNode node) { - return defaultVisit(node); - } - - /** - * Visit a ParenthesesNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitParenthesesNode(Nodes.ParenthesesNode node) { - return defaultVisit(node); - } - - /** - * Visit a PinnedExpressionNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitPinnedExpressionNode(Nodes.PinnedExpressionNode node) { - return defaultVisit(node); - } - - /** - * Visit a PinnedVariableNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitPinnedVariableNode(Nodes.PinnedVariableNode node) { - return defaultVisit(node); - } - - /** - * Visit a PostExecutionNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitPostExecutionNode(Nodes.PostExecutionNode node) { - return defaultVisit(node); - } - - /** - * Visit a PreExecutionNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitPreExecutionNode(Nodes.PreExecutionNode node) { - return defaultVisit(node); - } - - /** - * Visit a ProgramNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitProgramNode(Nodes.ProgramNode node) { - return defaultVisit(node); - } - - /** - * Visit a RangeNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRangeNode(Nodes.RangeNode node) { - return defaultVisit(node); - } - - /** - * Visit a RationalNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRationalNode(Nodes.RationalNode node) { - return defaultVisit(node); - } - - /** - * Visit a RedoNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRedoNode(Nodes.RedoNode node) { - return defaultVisit(node); - } - - /** - * Visit a RegularExpressionNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRegularExpressionNode(Nodes.RegularExpressionNode node) { - return defaultVisit(node); - } - - /** - * Visit a RequiredKeywordParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRequiredKeywordParameterNode(Nodes.RequiredKeywordParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a RequiredParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRequiredParameterNode(Nodes.RequiredParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a RescueModifierNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRescueModifierNode(Nodes.RescueModifierNode node) { - return defaultVisit(node); - } - - /** - * Visit a RescueNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRescueNode(Nodes.RescueNode node) { - return defaultVisit(node); - } - - /** - * Visit a RestParameterNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRestParameterNode(Nodes.RestParameterNode node) { - return defaultVisit(node); - } - - /** - * Visit a RetryNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitRetryNode(Nodes.RetryNode node) { - return defaultVisit(node); - } - - /** - * Visit a ReturnNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitReturnNode(Nodes.ReturnNode node) { - return defaultVisit(node); - } - - /** - * Visit a SelfNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSelfNode(Nodes.SelfNode node) { - return defaultVisit(node); - } - - /** - * Visit a ShareableConstantNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitShareableConstantNode(Nodes.ShareableConstantNode node) { - return defaultVisit(node); - } - - /** - * Visit a SingletonClassNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSingletonClassNode(Nodes.SingletonClassNode node) { - return defaultVisit(node); - } - - /** - * Visit a SourceEncodingNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSourceEncodingNode(Nodes.SourceEncodingNode node) { - return defaultVisit(node); - } - - /** - * Visit a SourceFileNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSourceFileNode(Nodes.SourceFileNode node) { - return defaultVisit(node); - } - - /** - * Visit a SourceLineNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSourceLineNode(Nodes.SourceLineNode node) { - return defaultVisit(node); - } - - /** - * Visit a SplatNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSplatNode(Nodes.SplatNode node) { - return defaultVisit(node); - } - - /** - * Visit a StatementsNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitStatementsNode(Nodes.StatementsNode node) { - return defaultVisit(node); - } - - /** - * Visit a StringNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitStringNode(Nodes.StringNode node) { - return defaultVisit(node); - } - - /** - * Visit a SuperNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSuperNode(Nodes.SuperNode node) { - return defaultVisit(node); - } - - /** - * Visit a SymbolNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitSymbolNode(Nodes.SymbolNode node) { - return defaultVisit(node); - } - - /** - * Visit a TrueNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitTrueNode(Nodes.TrueNode node) { - return defaultVisit(node); - } - - /** - * Visit a UndefNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitUndefNode(Nodes.UndefNode node) { - return defaultVisit(node); - } - - /** - * Visit a UnlessNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitUnlessNode(Nodes.UnlessNode node) { - return defaultVisit(node); - } - - /** - * Visit a UntilNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitUntilNode(Nodes.UntilNode node) { - return defaultVisit(node); - } - - /** - * Visit a WhenNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitWhenNode(Nodes.WhenNode node) { - return defaultVisit(node); - } - - /** - * Visit a WhileNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitWhileNode(Nodes.WhileNode node) { - return defaultVisit(node); - } - - /** - * Visit a XStringNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitXStringNode(Nodes.XStringNode node) { - return defaultVisit(node); - } - - /** - * Visit a YieldNode node. - * - * @param node The node to visit. - * @return The result of visiting the node. - */ - public T visitYieldNode(Nodes.YieldNode node) { - return defaultVisit(node); - } - -} -// @formatter:on diff --git a/src/main/java/org/prism/Loader.java b/src/main/java/org/prism/Loader.java deleted file mode 100644 index eaadfa0..0000000 --- a/src/main/java/org/prism/Loader.java +++ /dev/null @@ -1,775 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* This file is generated by the templates/template.rb script and should not */ -/* be modified manually. See */ -/* templates/java/org/prism/Loader.java.erb */ -/* if you are looking to modify the */ -/* template */ -/*----------------------------------------------------------------------------*/ - -package org.prism; - -import org.prism.Nodes; - -import java.lang.Short; -import java.math.BigInteger; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; -import java.util.Locale; - -// GENERATED BY Loader.java.erb -// @formatter:off -public class Loader { - - public static ParseResult load(byte[] serialized, byte[] sourceBytes) { - return new Loader(serialized, sourceBytes).load(); - } - - // Overridable methods - - public Charset getEncodingCharset(String encodingName) { - encodingName = encodingName.toLowerCase(Locale.ROOT); - if (encodingName.equals("ascii-8bit")) { - return StandardCharsets.US_ASCII; - } - return Charset.forName(encodingName); - } - - public org.jruby.RubySymbol bytesToName(byte[] bytes) { - return null; // Must be implemented by subclassing Loader - } - - private static final class ConstantPool { - - private final Loader loader; - private final byte[] source; - private final int bufferOffset; - private final org.jruby.RubySymbol[] cache; - - ConstantPool(Loader loader, byte[] source, int bufferOffset, int length) { - this.loader = loader; - this.source = source; - this.bufferOffset = bufferOffset; - cache = new org.jruby.RubySymbol[length]; - } - - org.jruby.RubySymbol get(ByteBuffer buffer, int oneBasedIndex) { - int index = oneBasedIndex - 1; - org.jruby.RubySymbol constant = cache[index]; - - if (constant == null) { - int offset = bufferOffset + index * 8; - int start = buffer.getInt(offset); - int length = buffer.getInt(offset + 4); - - byte[] bytes = new byte[length]; - - if (Integer.compareUnsigned(start, 0x7FFFFFFF) <= 0) { - System.arraycopy(source, start, bytes, 0, length); - } else { - int position = buffer.position(); - buffer.position(start & 0x7FFFFFFF); - buffer.get(bytes, 0, length); - buffer.position(position); - } - - constant = loader.bytesToName(bytes); - cache[index] = constant; - } - - return constant; - } - - } - - private final ByteBuffer buffer; - private final Nodes.Source source; - protected String encodingName; - private ConstantPool constantPool; - - protected Loader(byte[] serialized, byte[] sourceBytes) { - this.buffer = ByteBuffer.wrap(serialized).order(ByteOrder.nativeOrder()); - this.source = new Nodes.Source(sourceBytes); - } - - protected ParseResult load() { - expect((byte) 'P', "incorrect prism header"); - expect((byte) 'R', "incorrect prism header"); - expect((byte) 'I', "incorrect prism header"); - expect((byte) 'S', "incorrect prism header"); - expect((byte) 'M', "incorrect prism header"); - - expect((byte) 1, "prism major version does not match"); - expect((byte) 4, "prism minor version does not match"); - expect((byte) 0, "prism patch version does not match"); - - expect((byte) 1, "Loader.java requires no location fields in the serialized output"); - - // This loads the name of the encoding. - int encodingLength = loadVarUInt(); - byte[] encodingNameBytes = new byte[encodingLength]; - buffer.get(encodingNameBytes); - this.encodingName = new String(encodingNameBytes, StandardCharsets.US_ASCII); - - source.setStartLine(loadVarSInt()); - source.setLineOffsets(loadLineOffsets()); - - ParseResult.MagicComment[] magicComments = loadMagicComments(); - Nodes.Location dataLocation = loadOptionalLocation(); - ParseResult.Error[] errors = loadErrors(); - ParseResult.Warning[] warnings = loadWarnings(); - - int constantPoolBufferOffset = buffer.getInt(); - int constantPoolLength = loadVarUInt(); - this.constantPool = new ConstantPool(this, source.bytes, constantPoolBufferOffset, constantPoolLength); - - Nodes.Node node; - if (errors.length == 0) { - node = loadNode(); - - int left = constantPoolBufferOffset - buffer.position(); - if (left != 0) { - throw new Error("Expected to consume all bytes while deserializing but there were " + left + " bytes left"); - } - - boolean[] newlineMarked = new boolean[1 + source.getLineCount()]; - MarkNewlinesVisitor visitor = new MarkNewlinesVisitor(source, newlineMarked); - node.accept(visitor); - } else { - node = null; - } - - return new ParseResult(node, magicComments, dataLocation, errors, warnings, source); - } - - private byte[] loadEmbeddedString() { - int length = loadVarUInt(); - byte[] bytes = new byte[length]; - buffer.get(bytes); - return bytes; - } - - private byte[] loadString() { - switch (buffer.get()) { - case 1: - int start = loadVarUInt(); - int length = loadVarUInt(); - byte[] bytes = new byte[length]; - System.arraycopy(source.bytes, start, bytes, 0, length); - return bytes; - case 2: - return loadEmbeddedString(); - default: - throw new Error("Expected 0 or 1 but was " + buffer.get()); - } - } - - private int[] loadLineOffsets() { - int count = loadVarUInt(); - int[] lineOffsets = new int[count]; - for (int i = 0; i < count; i++) { - lineOffsets[i] = loadVarUInt(); - } - return lineOffsets; - } - - private ParseResult.MagicComment[] loadMagicComments() { - int count = loadVarUInt(); - ParseResult.MagicComment[] magicComments = new ParseResult.MagicComment[count]; - - for (int i = 0; i < count; i++) { - Nodes.Location keyLocation = loadLocation(); - Nodes.Location valueLocation = loadLocation(); - - ParseResult.MagicComment magicComment = new ParseResult.MagicComment(keyLocation, valueLocation); - magicComments[i] = magicComment; - } - - return magicComments; - } - - private ParseResult.Error[] loadErrors() { - int count = loadVarUInt(); - ParseResult.Error[] errors = new ParseResult.Error[count]; - - // error messages only contain ASCII characters - for (int i = 0; i < count; i++) { - Nodes.ErrorType type = Nodes.ERROR_TYPES[loadVarUInt()]; - byte[] bytes = loadEmbeddedString(); - String message = new String(bytes, StandardCharsets.US_ASCII); - Nodes.Location location = loadLocation(); - ParseResult.ErrorLevel level = ParseResult.ERROR_LEVELS[buffer.get()]; - - ParseResult.Error error = new ParseResult.Error(type, message, location, level); - errors[i] = error; - } - - return errors; - } - - private ParseResult.Warning[] loadWarnings() { - int count = loadVarUInt(); - ParseResult.Warning[] warnings = new ParseResult.Warning[count]; - - // warning messages only contain ASCII characters - for (int i = 0; i < count; i++) { - Nodes.WarningType type = Nodes.WARNING_TYPES[loadVarUInt() - 289]; - byte[] bytes = loadEmbeddedString(); - String message = new String(bytes, StandardCharsets.US_ASCII); - Nodes.Location location = loadLocation(); - ParseResult.WarningLevel level = ParseResult.WARNING_LEVELS[buffer.get()]; - - ParseResult.Warning warning = new ParseResult.Warning(type, message, location, level); - warnings[i] = warning; - } - - return warnings; - } - - private Nodes.Node loadOptionalNode() { - if (buffer.get(buffer.position()) != 0) { - return loadNode(); - } else { - buffer.position(buffer.position() + 1); // continue after the 0 byte - return null; - } - } - - private org.jruby.RubySymbol loadConstant() { - return constantPool.get(buffer, loadVarUInt()); - } - - private org.jruby.RubySymbol loadOptionalConstant() { - if (buffer.get(buffer.position()) != 0) { - return loadConstant(); - } else { - buffer.position(buffer.position() + 1); // continue after the 0 byte - return null; - } - } - - private org.jruby.RubySymbol[] loadConstants() { - int length = loadVarUInt(); - if (length == 0) { - return Nodes.EMPTY_STRING_ARRAY; - } - org.jruby.RubySymbol[] constants = new org.jruby.RubySymbol[length]; - for (int i = 0; i < length; i++) { - constants[i] = constantPool.get(buffer, loadVarUInt()); - } - return constants; - } - - private Nodes.Location loadLocation() { - return new Nodes.Location(loadVarUInt(), loadVarUInt()); - } - - private Nodes.Location loadOptionalLocation() { - if (buffer.get() != 0) { - return loadLocation(); - } else { - return null; - } - } - - // From https://github.com/protocolbuffers/protobuf/blob/v23.1/java/core/src/main/java/com/google/protobuf/BinaryReader.java#L1507 - private int loadVarUInt() { - int x; - if ((x = buffer.get()) >= 0) { - return x; - } else if ((x ^= (buffer.get() << 7)) < 0) { - x ^= (~0 << 7); - } else if ((x ^= (buffer.get() << 14)) >= 0) { - x ^= (~0 << 7) ^ (~0 << 14); - } else if ((x ^= (buffer.get() << 21)) < 0) { - x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21); - } else { - x ^= buffer.get() << 28; - x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) ^ (~0 << 28); - } - return x; - } - - // From https://github.com/protocolbuffers/protobuf/blob/v25.1/java/core/src/main/java/com/google/protobuf/CodedInputStream.java#L508-L510 - private int loadVarSInt() { - int x = loadVarUInt(); - return (x >>> 1) ^ (-(x & 1)); - } - - private short loadFlags() { - int flags = loadVarUInt(); - assert flags >= 0 && flags <= Short.MAX_VALUE; - return (short) flags; - } - - private static final BigInteger UNSIGNED_LONG_MASK = BigInteger.ONE.shiftLeft(Long.SIZE).subtract(BigInteger.ONE); - - private Object loadInteger() { - boolean negative = buffer.get() != 0; - - int wordsLength = loadVarUInt(); - assert wordsLength > 0; - - // Load the first word. If it's the only word, then return an int if it - // fits into one and a long otherwise. - int firstWord = loadVarUInt(); - if (wordsLength == 1) { - if (firstWord < 0) { - if (negative && firstWord == Integer.MIN_VALUE) { - return Integer.MIN_VALUE; - } - - long words = Integer.toUnsignedLong(firstWord); - return negative ? -words : words; - } - return negative ? -firstWord : firstWord; - } - - // Load the second word. If there are only two words, then return a long - // if it fits into one and a BigInteger otherwise. - int secondWord = loadVarUInt(); - if (wordsLength == 2) { - long words = (((long) secondWord) << 32L) | Integer.toUnsignedLong(firstWord); - if (words < 0L) { - if (negative && words == Long.MIN_VALUE) { - return Long.MIN_VALUE; - } - - BigInteger result = BigInteger.valueOf(words).and(UNSIGNED_LONG_MASK); - return negative ? result.negate() : result; - } - return negative ? -words : words; - } - - // Otherwise, load the remaining words and return a BigInt. - BigInteger result = BigInteger.valueOf(Integer.toUnsignedLong(firstWord)); - result = result.or(BigInteger.valueOf(Integer.toUnsignedLong(secondWord)).shiftLeft(32)); - - for (int wordsIndex = 2; wordsIndex < wordsLength; wordsIndex++) { - result = result.or(BigInteger.valueOf(Integer.toUnsignedLong(loadVarUInt())).shiftLeft(wordsIndex * 32)); - } - - return negative ? result.negate() : result; - } - - private Nodes.Node loadNode() { - int type = buffer.get() & 0xFF; - int startOffset = loadVarUInt(); - int length = loadVarUInt(); - - switch (type) { - case 1: - return new Nodes.AliasGlobalVariableNode(startOffset, length, loadNode(), loadNode()); - case 2: - return new Nodes.AliasMethodNode(startOffset, length, loadNode(), loadNode()); - case 3: - return new Nodes.AlternationPatternNode(startOffset, length, loadNode(), loadNode()); - case 4: - return new Nodes.AndNode(startOffset, length, loadNode(), loadNode()); - case 5: - return new Nodes.ArgumentsNode(startOffset, length, loadFlags(), loadNodes()); - case 6: - return new Nodes.ArrayNode(startOffset, length, loadFlags(), loadNodes()); - case 7: - return new Nodes.ArrayPatternNode(startOffset, length, loadOptionalNode(), loadNodes(), loadOptionalNode(), loadNodes()); - case 8: - return new Nodes.AssocNode(startOffset, length, loadNode(), loadNode()); - case 9: - return new Nodes.AssocSplatNode(startOffset, length, loadOptionalNode()); - case 10: - return new Nodes.BackReferenceReadNode(startOffset, length, loadConstant()); - case 11: - return new Nodes.BeginNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode(), (Nodes.RescueNode) loadOptionalNode(), (Nodes.ElseNode) loadOptionalNode(), (Nodes.EnsureNode) loadOptionalNode()); - case 12: - return new Nodes.BlockArgumentNode(startOffset, length, loadOptionalNode()); - case 13: - return new Nodes.BlockLocalVariableNode(startOffset, length, loadFlags(), loadConstant()); - case 14: - return new Nodes.BlockNode(startOffset, length, loadConstants(), loadOptionalNode(), loadOptionalNode()); - case 15: - return new Nodes.BlockParameterNode(startOffset, length, loadFlags(), loadOptionalConstant()); - case 16: - return new Nodes.BlockParametersNode(startOffset, length, (Nodes.ParametersNode) loadOptionalNode(), loadBlockLocalVariableNodes()); - case 17: - return new Nodes.BreakNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); - case 18: - return new Nodes.CallAndWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadNode()); - case 19: - return new Nodes.CallNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode()); - case 20: - return new Nodes.CallOperatorWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadConstant(), loadNode()); - case 21: - return new Nodes.CallOrWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), loadConstant(), loadConstant(), loadNode()); - case 22: - return new Nodes.CallTargetNode(startOffset, length, loadFlags(), loadNode(), loadConstant()); - case 23: - return new Nodes.CapturePatternNode(startOffset, length, loadNode(), (Nodes.LocalVariableTargetNode) loadNode()); - case 24: - return new Nodes.CaseMatchNode(startOffset, length, loadOptionalNode(), loadInNodes(), (Nodes.ElseNode) loadOptionalNode()); - case 25: - return new Nodes.CaseNode(startOffset, length, loadOptionalNode(), loadWhenNodes(), (Nodes.ElseNode) loadOptionalNode()); - case 26: - return new Nodes.ClassNode(startOffset, length, loadConstants(), loadNode(), loadOptionalNode(), loadOptionalNode(), loadConstant()); - case 27: - return new Nodes.ClassVariableAndWriteNode(startOffset, length, loadConstant(), loadNode()); - case 28: - return new Nodes.ClassVariableOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); - case 29: - return new Nodes.ClassVariableOrWriteNode(startOffset, length, loadConstant(), loadNode()); - case 30: - return new Nodes.ClassVariableReadNode(startOffset, length, loadConstant()); - case 31: - return new Nodes.ClassVariableTargetNode(startOffset, length, loadConstant()); - case 32: - return new Nodes.ClassVariableWriteNode(startOffset, length, loadConstant(), loadNode()); - case 33: - return new Nodes.ConstantAndWriteNode(startOffset, length, loadConstant(), loadNode()); - case 34: - return new Nodes.ConstantOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); - case 35: - return new Nodes.ConstantOrWriteNode(startOffset, length, loadConstant(), loadNode()); - case 36: - return new Nodes.ConstantPathAndWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode()); - case 37: - return new Nodes.ConstantPathNode(startOffset, length, loadOptionalNode(), loadOptionalConstant()); - case 38: - return new Nodes.ConstantPathOperatorWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode(), loadConstant()); - case 39: - return new Nodes.ConstantPathOrWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode()); - case 40: - return new Nodes.ConstantPathTargetNode(startOffset, length, loadOptionalNode(), loadOptionalConstant()); - case 41: - return new Nodes.ConstantPathWriteNode(startOffset, length, (Nodes.ConstantPathNode) loadNode(), loadNode()); - case 42: - return new Nodes.ConstantReadNode(startOffset, length, loadConstant()); - case 43: - return new Nodes.ConstantTargetNode(startOffset, length, loadConstant()); - case 44: - return new Nodes.ConstantWriteNode(startOffset, length, loadConstant(), loadNode()); - case 45: - return new Nodes.DefNode(startOffset, length, buffer.getInt(), loadConstant(), loadOptionalNode(), (Nodes.ParametersNode) loadOptionalNode(), loadOptionalNode(), loadConstants()); - case 46: - return new Nodes.DefinedNode(startOffset, length, loadNode()); - case 47: - return new Nodes.ElseNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); - case 48: - return new Nodes.EmbeddedStatementsNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); - case 49: - return new Nodes.EmbeddedVariableNode(startOffset, length, loadNode()); - case 50: - return new Nodes.EnsureNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); - case 51: - return new Nodes.FalseNode(startOffset, length); - case 52: - return new Nodes.FindPatternNode(startOffset, length, loadOptionalNode(), (Nodes.SplatNode) loadNode(), loadNodes(), (Nodes.SplatNode) loadNode()); - case 53: - return new Nodes.FlipFlopNode(startOffset, length, loadFlags(), loadOptionalNode(), loadOptionalNode()); - case 54: - return new Nodes.FloatNode(startOffset, length, buffer.getDouble()); - case 55: - return new Nodes.ForNode(startOffset, length, loadNode(), loadNode(), (Nodes.StatementsNode) loadOptionalNode()); - case 56: - return new Nodes.ForwardingArgumentsNode(startOffset, length); - case 57: - return new Nodes.ForwardingParameterNode(startOffset, length); - case 58: - return new Nodes.ForwardingSuperNode(startOffset, length, (Nodes.BlockNode) loadOptionalNode()); - case 59: - return new Nodes.GlobalVariableAndWriteNode(startOffset, length, loadConstant(), loadNode()); - case 60: - return new Nodes.GlobalVariableOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); - case 61: - return new Nodes.GlobalVariableOrWriteNode(startOffset, length, loadConstant(), loadNode()); - case 62: - return new Nodes.GlobalVariableReadNode(startOffset, length, loadConstant()); - case 63: - return new Nodes.GlobalVariableTargetNode(startOffset, length, loadConstant()); - case 64: - return new Nodes.GlobalVariableWriteNode(startOffset, length, loadConstant(), loadNode()); - case 65: - return new Nodes.HashNode(startOffset, length, loadNodes()); - case 66: - return new Nodes.HashPatternNode(startOffset, length, loadOptionalNode(), loadAssocNodes(), loadOptionalNode()); - case 67: - return new Nodes.IfNode(startOffset, length, loadNode(), (Nodes.StatementsNode) loadOptionalNode(), loadOptionalNode()); - case 68: - return new Nodes.ImaginaryNode(startOffset, length, loadNode()); - case 69: - return new Nodes.ImplicitNode(startOffset, length, loadNode()); - case 70: - return new Nodes.ImplicitRestNode(startOffset, length); - case 71: - return new Nodes.InNode(startOffset, length, loadNode(), (Nodes.StatementsNode) loadOptionalNode()); - case 72: - return new Nodes.IndexAndWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode(), loadNode()); - case 73: - return new Nodes.IndexOperatorWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode(), loadConstant(), loadNode()); - case 74: - return new Nodes.IndexOrWriteNode(startOffset, length, loadFlags(), loadOptionalNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode(), loadNode()); - case 75: - return new Nodes.IndexTargetNode(startOffset, length, loadFlags(), loadNode(), (Nodes.ArgumentsNode) loadOptionalNode(), (Nodes.BlockArgumentNode) loadOptionalNode()); - case 76: - return new Nodes.InstanceVariableAndWriteNode(startOffset, length, loadConstant(), loadNode()); - case 77: - return new Nodes.InstanceVariableOperatorWriteNode(startOffset, length, loadConstant(), loadNode(), loadConstant()); - case 78: - return new Nodes.InstanceVariableOrWriteNode(startOffset, length, loadConstant(), loadNode()); - case 79: - return new Nodes.InstanceVariableReadNode(startOffset, length, loadConstant()); - case 80: - return new Nodes.InstanceVariableTargetNode(startOffset, length, loadConstant()); - case 81: - return new Nodes.InstanceVariableWriteNode(startOffset, length, loadConstant(), loadNode()); - case 82: - return new Nodes.IntegerNode(startOffset, length, loadFlags(), loadInteger()); - case 83: - return new Nodes.InterpolatedMatchLastLineNode(startOffset, length, loadFlags(), loadNodes()); - case 84: - return new Nodes.InterpolatedRegularExpressionNode(startOffset, length, loadFlags(), loadNodes()); - case 85: - return new Nodes.InterpolatedStringNode(startOffset, length, loadFlags(), loadNodes()); - case 86: - return new Nodes.InterpolatedSymbolNode(startOffset, length, loadNodes()); - case 87: - return new Nodes.InterpolatedXStringNode(startOffset, length, loadNodes()); - case 88: - return new Nodes.ItLocalVariableReadNode(startOffset, length); - case 89: - return new Nodes.ItParametersNode(startOffset, length); - case 90: - return new Nodes.KeywordHashNode(startOffset, length, loadFlags(), loadNodes()); - case 91: - return new Nodes.KeywordRestParameterNode(startOffset, length, loadFlags(), loadOptionalConstant()); - case 92: - return new Nodes.LambdaNode(startOffset, length, loadConstants(), loadOptionalNode(), loadOptionalNode()); - case 93: - return new Nodes.LocalVariableAndWriteNode(startOffset, length, loadNode(), loadConstant(), loadVarUInt()); - case 94: - return new Nodes.LocalVariableOperatorWriteNode(startOffset, length, loadNode(), loadConstant(), loadConstant(), loadVarUInt()); - case 95: - return new Nodes.LocalVariableOrWriteNode(startOffset, length, loadNode(), loadConstant(), loadVarUInt()); - case 96: - return new Nodes.LocalVariableReadNode(startOffset, length, loadConstant(), loadVarUInt()); - case 97: - return new Nodes.LocalVariableTargetNode(startOffset, length, loadConstant(), loadVarUInt()); - case 98: - return new Nodes.LocalVariableWriteNode(startOffset, length, loadConstant(), loadVarUInt(), loadNode()); - case 99: - return new Nodes.MatchLastLineNode(startOffset, length, loadFlags(), loadString()); - case 100: - return new Nodes.MatchPredicateNode(startOffset, length, loadNode(), loadNode()); - case 101: - return new Nodes.MatchRequiredNode(startOffset, length, loadNode(), loadNode()); - case 102: - return new Nodes.MatchWriteNode(startOffset, length, (Nodes.CallNode) loadNode(), loadLocalVariableTargetNodes()); - case 103: - return new Nodes.MissingNode(startOffset, length); - case 104: - return new Nodes.ModuleNode(startOffset, length, loadConstants(), loadNode(), loadOptionalNode(), loadConstant()); - case 105: - return new Nodes.MultiTargetNode(startOffset, length, loadNodes(), loadOptionalNode(), loadNodes()); - case 106: - return new Nodes.MultiWriteNode(startOffset, length, loadNodes(), loadOptionalNode(), loadNodes(), loadNode()); - case 107: - return new Nodes.NextNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); - case 108: - return new Nodes.NilNode(startOffset, length); - case 109: - return new Nodes.NoKeywordsParameterNode(startOffset, length); - case 110: - return new Nodes.NumberedParametersNode(startOffset, length, buffer.get()); - case 111: - return new Nodes.NumberedReferenceReadNode(startOffset, length, loadVarUInt()); - case 112: - return new Nodes.OptionalKeywordParameterNode(startOffset, length, loadFlags(), loadConstant(), loadNode()); - case 113: - return new Nodes.OptionalParameterNode(startOffset, length, loadFlags(), loadConstant(), loadNode()); - case 114: - return new Nodes.OrNode(startOffset, length, loadNode(), loadNode()); - case 115: - return new Nodes.ParametersNode(startOffset, length, loadNodes(), loadOptionalParameterNodes(), loadOptionalNode(), loadNodes(), loadNodes(), loadOptionalNode(), (Nodes.BlockParameterNode) loadOptionalNode()); - case 116: - return new Nodes.ParenthesesNode(startOffset, length, loadFlags(), loadOptionalNode()); - case 117: - return new Nodes.PinnedExpressionNode(startOffset, length, loadNode()); - case 118: - return new Nodes.PinnedVariableNode(startOffset, length, loadNode()); - case 119: - return new Nodes.PostExecutionNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); - case 120: - return new Nodes.PreExecutionNode(startOffset, length, (Nodes.StatementsNode) loadOptionalNode()); - case 121: - return new Nodes.ProgramNode(startOffset, length, loadConstants(), (Nodes.StatementsNode) loadNode()); - case 122: - return new Nodes.RangeNode(startOffset, length, loadFlags(), loadOptionalNode(), loadOptionalNode()); - case 123: - return new Nodes.RationalNode(startOffset, length, loadFlags(), loadInteger(), loadInteger()); - case 124: - return new Nodes.RedoNode(startOffset, length); - case 125: - return new Nodes.RegularExpressionNode(startOffset, length, loadFlags(), loadString()); - case 126: - return new Nodes.RequiredKeywordParameterNode(startOffset, length, loadFlags(), loadConstant()); - case 127: - return new Nodes.RequiredParameterNode(startOffset, length, loadFlags(), loadConstant()); - case 128: - return new Nodes.RescueModifierNode(startOffset, length, loadNode(), loadNode()); - case 129: - return new Nodes.RescueNode(startOffset, length, loadNodes(), loadOptionalNode(), (Nodes.StatementsNode) loadOptionalNode(), (Nodes.RescueNode) loadOptionalNode()); - case 130: - return new Nodes.RestParameterNode(startOffset, length, loadFlags(), loadOptionalConstant()); - case 131: - return new Nodes.RetryNode(startOffset, length); - case 132: - return new Nodes.ReturnNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); - case 133: - return new Nodes.SelfNode(startOffset, length); - case 134: - return new Nodes.ShareableConstantNode(startOffset, length, loadFlags(), loadNode()); - case 135: - return new Nodes.SingletonClassNode(startOffset, length, loadConstants(), loadNode(), loadOptionalNode()); - case 136: - return new Nodes.SourceEncodingNode(startOffset, length); - case 137: - return new Nodes.SourceFileNode(startOffset, length, loadFlags(), loadString()); - case 138: - return new Nodes.SourceLineNode(startOffset, length); - case 139: - return new Nodes.SplatNode(startOffset, length, loadOptionalNode()); - case 140: - return new Nodes.StatementsNode(startOffset, length, loadNodes()); - case 141: - return new Nodes.StringNode(startOffset, length, loadFlags(), loadString()); - case 142: - return new Nodes.SuperNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode(), loadOptionalNode()); - case 143: - return new Nodes.SymbolNode(startOffset, length, loadFlags(), loadString()); - case 144: - return new Nodes.TrueNode(startOffset, length); - case 145: - return new Nodes.UndefNode(startOffset, length, loadNodes()); - case 146: - return new Nodes.UnlessNode(startOffset, length, loadNode(), (Nodes.StatementsNode) loadOptionalNode(), (Nodes.ElseNode) loadOptionalNode()); - case 147: - return new Nodes.UntilNode(startOffset, length, loadFlags(), loadNode(), (Nodes.StatementsNode) loadOptionalNode()); - case 148: - return new Nodes.WhenNode(startOffset, length, loadNodes(), (Nodes.StatementsNode) loadOptionalNode()); - case 149: - return new Nodes.WhileNode(startOffset, length, loadFlags(), loadNode(), (Nodes.StatementsNode) loadOptionalNode()); - case 150: - return new Nodes.XStringNode(startOffset, length, loadFlags(), loadString()); - case 151: - return new Nodes.YieldNode(startOffset, length, (Nodes.ArgumentsNode) loadOptionalNode()); - default: - throw new Error("Unknown node type: " + type); - } - } - - private static final Nodes.Node[] EMPTY_Node_ARRAY = {}; - - private Nodes.Node[] loadNodes() { - int length = loadVarUInt(); - if (length == 0) { - return EMPTY_Node_ARRAY; - } - Nodes.Node[] nodes = new Nodes.Node[length]; - for (int i = 0; i < length; i++) { - nodes[i] = loadNode(); - } - return nodes; - } - - private static final Nodes.BlockLocalVariableNode[] EMPTY_BlockLocalVariableNode_ARRAY = {}; - - private Nodes.BlockLocalVariableNode[] loadBlockLocalVariableNodes() { - int length = loadVarUInt(); - if (length == 0) { - return EMPTY_BlockLocalVariableNode_ARRAY; - } - Nodes.BlockLocalVariableNode[] nodes = new Nodes.BlockLocalVariableNode[length]; - for (int i = 0; i < length; i++) { - nodes[i] = (Nodes.BlockLocalVariableNode) loadNode(); - } - return nodes; - } - - private static final Nodes.InNode[] EMPTY_InNode_ARRAY = {}; - - private Nodes.InNode[] loadInNodes() { - int length = loadVarUInt(); - if (length == 0) { - return EMPTY_InNode_ARRAY; - } - Nodes.InNode[] nodes = new Nodes.InNode[length]; - for (int i = 0; i < length; i++) { - nodes[i] = (Nodes.InNode) loadNode(); - } - return nodes; - } - - private static final Nodes.WhenNode[] EMPTY_WhenNode_ARRAY = {}; - - private Nodes.WhenNode[] loadWhenNodes() { - int length = loadVarUInt(); - if (length == 0) { - return EMPTY_WhenNode_ARRAY; - } - Nodes.WhenNode[] nodes = new Nodes.WhenNode[length]; - for (int i = 0; i < length; i++) { - nodes[i] = (Nodes.WhenNode) loadNode(); - } - return nodes; - } - - private static final Nodes.AssocNode[] EMPTY_AssocNode_ARRAY = {}; - - private Nodes.AssocNode[] loadAssocNodes() { - int length = loadVarUInt(); - if (length == 0) { - return EMPTY_AssocNode_ARRAY; - } - Nodes.AssocNode[] nodes = new Nodes.AssocNode[length]; - for (int i = 0; i < length; i++) { - nodes[i] = (Nodes.AssocNode) loadNode(); - } - return nodes; - } - - private static final Nodes.LocalVariableTargetNode[] EMPTY_LocalVariableTargetNode_ARRAY = {}; - - private Nodes.LocalVariableTargetNode[] loadLocalVariableTargetNodes() { - int length = loadVarUInt(); - if (length == 0) { - return EMPTY_LocalVariableTargetNode_ARRAY; - } - Nodes.LocalVariableTargetNode[] nodes = new Nodes.LocalVariableTargetNode[length]; - for (int i = 0; i < length; i++) { - nodes[i] = (Nodes.LocalVariableTargetNode) loadNode(); - } - return nodes; - } - - private static final Nodes.OptionalParameterNode[] EMPTY_OptionalParameterNode_ARRAY = {}; - - private Nodes.OptionalParameterNode[] loadOptionalParameterNodes() { - int length = loadVarUInt(); - if (length == 0) { - return EMPTY_OptionalParameterNode_ARRAY; - } - Nodes.OptionalParameterNode[] nodes = new Nodes.OptionalParameterNode[length]; - for (int i = 0; i < length; i++) { - nodes[i] = (Nodes.OptionalParameterNode) loadNode(); - } - return nodes; - } - - private void expect(byte value, String error) { - byte b = buffer.get(); - if (b != value) { - throw new Error("Deserialization error: " + error + " (expected " + value + " but was " + b + " at position " + buffer.position() + ")"); - } - } - -} -// @formatter:on diff --git a/src/main/java/org/prism/MarkNewlinesVisitor.java b/src/main/java/org/prism/MarkNewlinesVisitor.java deleted file mode 100644 index 27ab864..0000000 --- a/src/main/java/org/prism/MarkNewlinesVisitor.java +++ /dev/null @@ -1,62 +0,0 @@ -package org.prism; - -// Keep in sync with Ruby MarkNewlinesVisitor -final class MarkNewlinesVisitor extends AbstractNodeVisitor { - - private final Nodes.Source source; - private boolean[] newlineMarked; - - MarkNewlinesVisitor(Nodes.Source source, boolean[] newlineMarked) { - this.source = source; - this.newlineMarked = newlineMarked; - } - - @Override - public Void visitBlockNode(Nodes.BlockNode node) { - boolean[] oldNewlineMarked = this.newlineMarked; - this.newlineMarked = new boolean[oldNewlineMarked.length]; - try { - return super.visitBlockNode(node); - } finally { - this.newlineMarked = oldNewlineMarked; - } - } - - @Override - public Void visitLambdaNode(Nodes.LambdaNode node) { - boolean[] oldNewlineMarked = this.newlineMarked; - this.newlineMarked = new boolean[oldNewlineMarked.length]; - try { - return super.visitLambdaNode(node); - } finally { - this.newlineMarked = oldNewlineMarked; - } - } - - @Override - public Void visitIfNode(Nodes.IfNode node) { - node.setNewLineFlag(this.source, this.newlineMarked); - return super.visitIfNode(node); - } - - @Override - public Void visitUnlessNode(Nodes.UnlessNode node) { - node.setNewLineFlag(this.source, this.newlineMarked); - return super.visitUnlessNode(node); - } - - @Override - public Void visitStatementsNode(Nodes.StatementsNode node) { - for (Nodes.Node child : node.body) { - child.setNewLineFlag(this.source, this.newlineMarked); - } - return super.visitStatementsNode(node); - } - - @Override - protected Void defaultVisit(Nodes.Node node) { - node.visitChildNodes(this); - return null; - } - -} diff --git a/src/main/java/org/prism/Nodes.java b/src/main/java/org/prism/Nodes.java deleted file mode 100644 index 2a28178..0000000 --- a/src/main/java/org/prism/Nodes.java +++ /dev/null @@ -1,11340 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* This file is generated by the templates/template.rb script and should not */ -/* be modified manually. See */ -/* templates/java/org/prism/Nodes.java.erb */ -/* if you are looking to modify the */ -/* template */ -/*----------------------------------------------------------------------------*/ - -package org.prism; - -import java.lang.Override; -import java.lang.String; -import java.lang.StringBuilder; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; -import java.nio.charset.StandardCharsets; -import java.util.ArrayList; -import java.util.Arrays; - -// GENERATED BY Nodes.java.erb -// @formatter:off -public abstract class Nodes { - - public static final org.jruby.RubySymbol[] EMPTY_STRING_ARRAY = {}; - - @Target(ElementType.FIELD) - @Retention(RetentionPolicy.SOURCE) - public @interface Nullable { - } - - @Target(ElementType.FIELD) - @Retention(RetentionPolicy.SOURCE) - public @interface UnionType { - Class[] value(); - } - - public static final class Location { - - public static final Location[] EMPTY_ARRAY = {}; - - public final int startOffset; - public final int length; - - public Location(int startOffset, int length) { - this.startOffset = startOffset; - this.length = length; - } - - public int endOffset() { - return startOffset + length; - } - } - - public static final class Source { - public final byte[] bytes; - private int startLine = 1; - private int[] lineOffsets = null; - - Source(byte[] bytes) { - this.bytes = bytes; - } - - void setStartLine(int startLine) { - this.startLine = startLine; - } - - void setLineOffsets(int[] lineOffsets) { - this.lineOffsets = lineOffsets; - } - - // 1-based - public int line(int byteOffset) { - return startLine + findLine(byteOffset); - } - - // 0-based - public int findLine(int byteOffset) { - if (byteOffset >= bytes.length) byteOffset = bytes.length - 1; - assert byteOffset >= 0 : byteOffset; - int index = Arrays.binarySearch(lineOffsets, byteOffset); - int line; - if (index < 0) { - line = -index - 2; - } else { - line = index; - } - assert line >= 0 && line <= getLineCount() : line; - return line; - } - - public int getLineCount() { - return lineOffsets.length; - } - } - - public static abstract class Node { - - public static final Node[] EMPTY_ARRAY = {}; - - public final int startOffset; - public final int length; - private boolean newLineFlag = false; - - public Node(int startOffset, int length) { - this.startOffset = startOffset; - this.length = length; - } - - public final int endOffset() { - return startOffset + length; - } - - public final boolean hasNewLineFlag() { - return newLineFlag; - } - - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - int line = source.findLine(this.startOffset); - if (!newlineMarked[line]) { - newlineMarked[line] = true; - this.newLineFlag = true; - } - } - - public void setNewLineFlag(boolean newLineFlag) { - this.newLineFlag = newLineFlag; - } - - public abstract T accept(AbstractNodeVisitor visitor); - - public abstract void visitChildNodes(AbstractNodeVisitor visitor); - - public abstract Node[] childNodes(); - - @Override - public String toString() { - return toString(""); - } - - protected abstract String toString(String indent); - } - - /** - * Flags for arguments nodes. - */ - public static final class ArgumentsNodeFlags implements Comparable { - - // if the arguments contain forwarding - public static final short CONTAINS_FORWARDING = 1 << 2; - - // if the arguments contain keywords - public static final short CONTAINS_KEYWORDS = 1 << 3; - - // if the arguments contain a keyword splat - public static final short CONTAINS_KEYWORD_SPLAT = 1 << 4; - - // if the arguments contain a splat - public static final short CONTAINS_SPLAT = 1 << 5; - - // if the arguments contain multiple splats - public static final short CONTAINS_MULTIPLE_SPLATS = 1 << 6; - - public static boolean isContainsForwarding(short flags) { - return (flags & CONTAINS_FORWARDING) != 0; - } - - public static boolean isContainsKeywords(short flags) { - return (flags & CONTAINS_KEYWORDS) != 0; - } - - public static boolean isContainsKeywordSplat(short flags) { - return (flags & CONTAINS_KEYWORD_SPLAT) != 0; - } - - public static boolean isContainsSplat(short flags) { - return (flags & CONTAINS_SPLAT) != 0; - } - - public static boolean isContainsMultipleSplats(short flags) { - return (flags & CONTAINS_MULTIPLE_SPLATS) != 0; - } - - private final short flags; - - public ArgumentsNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof ArgumentsNodeFlags)) { - return false; - } - - return flags == ((ArgumentsNodeFlags) other).flags; - } - - @Override - public int compareTo(ArgumentsNodeFlags other) { - return flags - other.flags; - } - - public boolean isContainsForwarding() { - return (flags & CONTAINS_FORWARDING) != 0; - } - - public boolean isContainsKeywords() { - return (flags & CONTAINS_KEYWORDS) != 0; - } - - public boolean isContainsKeywordSplat() { - return (flags & CONTAINS_KEYWORD_SPLAT) != 0; - } - - public boolean isContainsSplat() { - return (flags & CONTAINS_SPLAT) != 0; - } - - public boolean isContainsMultipleSplats() { - return (flags & CONTAINS_MULTIPLE_SPLATS) != 0; - } - - } - - /** - * Flags for array nodes. - */ - public static final class ArrayNodeFlags implements Comparable { - - // if array contains splat nodes - public static final short CONTAINS_SPLAT = 1 << 2; - - public static boolean isContainsSplat(short flags) { - return (flags & CONTAINS_SPLAT) != 0; - } - - private final short flags; - - public ArrayNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof ArrayNodeFlags)) { - return false; - } - - return flags == ((ArrayNodeFlags) other).flags; - } - - @Override - public int compareTo(ArrayNodeFlags other) { - return flags - other.flags; - } - - public boolean isContainsSplat() { - return (flags & CONTAINS_SPLAT) != 0; - } - - } - - /** - * Flags for call nodes. - */ - public static final class CallNodeFlags implements Comparable { - - // &. operator - public static final short SAFE_NAVIGATION = 1 << 2; - - // a call that could have been a local variable - public static final short VARIABLE_CALL = 1 << 3; - - // a call that is an attribute write, so the value being written should be returned - public static final short ATTRIBUTE_WRITE = 1 << 4; - - // a call that ignores method visibility - public static final short IGNORE_VISIBILITY = 1 << 5; - - public static boolean isSafeNavigation(short flags) { - return (flags & SAFE_NAVIGATION) != 0; - } - - public static boolean isVariableCall(short flags) { - return (flags & VARIABLE_CALL) != 0; - } - - public static boolean isAttributeWrite(short flags) { - return (flags & ATTRIBUTE_WRITE) != 0; - } - - public static boolean isIgnoreVisibility(short flags) { - return (flags & IGNORE_VISIBILITY) != 0; - } - - private final short flags; - - public CallNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof CallNodeFlags)) { - return false; - } - - return flags == ((CallNodeFlags) other).flags; - } - - @Override - public int compareTo(CallNodeFlags other) { - return flags - other.flags; - } - - public boolean isSafeNavigation() { - return (flags & SAFE_NAVIGATION) != 0; - } - - public boolean isVariableCall() { - return (flags & VARIABLE_CALL) != 0; - } - - public boolean isAttributeWrite() { - return (flags & ATTRIBUTE_WRITE) != 0; - } - - public boolean isIgnoreVisibility() { - return (flags & IGNORE_VISIBILITY) != 0; - } - - } - - /** - * Flags for nodes that have unescaped content. - */ - public static final class EncodingFlags implements Comparable { - - // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 2; - - // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 3; - - public static boolean isForcedUtf8Encoding(short flags) { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public static boolean isForcedBinaryEncoding(short flags) { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - private final short flags; - - public EncodingFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof EncodingFlags)) { - return false; - } - - return flags == ((EncodingFlags) other).flags; - } - - @Override - public int compareTo(EncodingFlags other) { - return flags - other.flags; - } - - public boolean isForcedUtf8Encoding() { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public boolean isForcedBinaryEncoding() { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - } - - /** - * Flags for integer nodes that correspond to the base of the integer. - */ - public static final class IntegerBaseFlags implements Comparable { - - // 0b prefix - public static final short BINARY = 1 << 2; - - // 0d or no prefix - public static final short DECIMAL = 1 << 3; - - // 0o or 0 prefix - public static final short OCTAL = 1 << 4; - - // 0x prefix - public static final short HEXADECIMAL = 1 << 5; - - public static boolean isBinary(short flags) { - return (flags & BINARY) != 0; - } - - public static boolean isDecimal(short flags) { - return (flags & DECIMAL) != 0; - } - - public static boolean isOctal(short flags) { - return (flags & OCTAL) != 0; - } - - public static boolean isHexadecimal(short flags) { - return (flags & HEXADECIMAL) != 0; - } - - private final short flags; - - public IntegerBaseFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof IntegerBaseFlags)) { - return false; - } - - return flags == ((IntegerBaseFlags) other).flags; - } - - @Override - public int compareTo(IntegerBaseFlags other) { - return flags - other.flags; - } - - public boolean isBinary() { - return (flags & BINARY) != 0; - } - - public boolean isDecimal() { - return (flags & DECIMAL) != 0; - } - - public boolean isOctal() { - return (flags & OCTAL) != 0; - } - - public boolean isHexadecimal() { - return (flags & HEXADECIMAL) != 0; - } - - } - - /** - * Flags for interpolated string nodes that indicated mutability if they are also marked as literals. - */ - public static final class InterpolatedStringNodeFlags implements Comparable { - - // frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - public static final short FROZEN = 1 << 2; - - // mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - public static final short MUTABLE = 1 << 3; - - public static boolean isFrozen(short flags) { - return (flags & FROZEN) != 0; - } - - public static boolean isMutable(short flags) { - return (flags & MUTABLE) != 0; - } - - private final short flags; - - public InterpolatedStringNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof InterpolatedStringNodeFlags)) { - return false; - } - - return flags == ((InterpolatedStringNodeFlags) other).flags; - } - - @Override - public int compareTo(InterpolatedStringNodeFlags other) { - return flags - other.flags; - } - - public boolean isFrozen() { - return (flags & FROZEN) != 0; - } - - public boolean isMutable() { - return (flags & MUTABLE) != 0; - } - - } - - /** - * Flags for keyword hash nodes. - */ - public static final class KeywordHashNodeFlags implements Comparable { - - // a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments - public static final short SYMBOL_KEYS = 1 << 2; - - public static boolean isSymbolKeys(short flags) { - return (flags & SYMBOL_KEYS) != 0; - } - - private final short flags; - - public KeywordHashNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof KeywordHashNodeFlags)) { - return false; - } - - return flags == ((KeywordHashNodeFlags) other).flags; - } - - @Override - public int compareTo(KeywordHashNodeFlags other) { - return flags - other.flags; - } - - public boolean isSymbolKeys() { - return (flags & SYMBOL_KEYS) != 0; - } - - } - - /** - * Flags for while and until loop nodes. - */ - public static final class LoopFlags implements Comparable { - - // a loop after a begin statement, so the body is executed first before the condition - public static final short BEGIN_MODIFIER = 1 << 2; - - public static boolean isBeginModifier(short flags) { - return (flags & BEGIN_MODIFIER) != 0; - } - - private final short flags; - - public LoopFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof LoopFlags)) { - return false; - } - - return flags == ((LoopFlags) other).flags; - } - - @Override - public int compareTo(LoopFlags other) { - return flags - other.flags; - } - - public boolean isBeginModifier() { - return (flags & BEGIN_MODIFIER) != 0; - } - - } - - /** - * Flags for parameter nodes. - */ - public static final class ParameterFlags implements Comparable { - - // a parameter name that has been repeated in the method signature - public static final short REPEATED_PARAMETER = 1 << 2; - - public static boolean isRepeatedParameter(short flags) { - return (flags & REPEATED_PARAMETER) != 0; - } - - private final short flags; - - public ParameterFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof ParameterFlags)) { - return false; - } - - return flags == ((ParameterFlags) other).flags; - } - - @Override - public int compareTo(ParameterFlags other) { - return flags - other.flags; - } - - public boolean isRepeatedParameter() { - return (flags & REPEATED_PARAMETER) != 0; - } - - } - - /** - * Flags for parentheses nodes. - */ - public static final class ParenthesesNodeFlags implements Comparable { - - // parentheses that contain multiple potentially void statements - public static final short MULTIPLE_STATEMENTS = 1 << 2; - - public static boolean isMultipleStatements(short flags) { - return (flags & MULTIPLE_STATEMENTS) != 0; - } - - private final short flags; - - public ParenthesesNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof ParenthesesNodeFlags)) { - return false; - } - - return flags == ((ParenthesesNodeFlags) other).flags; - } - - @Override - public int compareTo(ParenthesesNodeFlags other) { - return flags - other.flags; - } - - public boolean isMultipleStatements() { - return (flags & MULTIPLE_STATEMENTS) != 0; - } - - } - - /** - * Flags for range and flip-flop nodes. - */ - public static final class RangeFlags implements Comparable { - - // ... operator - public static final short EXCLUDE_END = 1 << 2; - - public static boolean isExcludeEnd(short flags) { - return (flags & EXCLUDE_END) != 0; - } - - private final short flags; - - public RangeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof RangeFlags)) { - return false; - } - - return flags == ((RangeFlags) other).flags; - } - - @Override - public int compareTo(RangeFlags other) { - return flags - other.flags; - } - - public boolean isExcludeEnd() { - return (flags & EXCLUDE_END) != 0; - } - - } - - /** - * Flags for regular expression and match last line nodes. - */ - public static final class RegularExpressionFlags implements Comparable { - - // i - ignores the case of characters when matching - public static final short IGNORE_CASE = 1 << 2; - - // x - ignores whitespace and allows comments in regular expressions - public static final short EXTENDED = 1 << 3; - - // m - allows $ to match the end of lines within strings - public static final short MULTI_LINE = 1 << 4; - - // o - only interpolates values into the regular expression once - public static final short ONCE = 1 << 5; - - // e - forces the EUC-JP encoding - public static final short EUC_JP = 1 << 6; - - // n - forces the ASCII-8BIT encoding - public static final short ASCII_8BIT = 1 << 7; - - // s - forces the Windows-31J encoding - public static final short WINDOWS_31J = 1 << 8; - - // u - forces the UTF-8 encoding - public static final short UTF_8 = 1 << 9; - - // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 10; - - // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 11; - - // internal bytes forced the encoding to US-ASCII - public static final short FORCED_US_ASCII_ENCODING = 1 << 12; - - public static boolean isIgnoreCase(short flags) { - return (flags & IGNORE_CASE) != 0; - } - - public static boolean isExtended(short flags) { - return (flags & EXTENDED) != 0; - } - - public static boolean isMultiLine(short flags) { - return (flags & MULTI_LINE) != 0; - } - - public static boolean isOnce(short flags) { - return (flags & ONCE) != 0; - } - - public static boolean isEucJp(short flags) { - return (flags & EUC_JP) != 0; - } - - public static boolean isAscii8bit(short flags) { - return (flags & ASCII_8BIT) != 0; - } - - public static boolean isWindows31j(short flags) { - return (flags & WINDOWS_31J) != 0; - } - - public static boolean isUtf8(short flags) { - return (flags & UTF_8) != 0; - } - - public static boolean isForcedUtf8Encoding(short flags) { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public static boolean isForcedBinaryEncoding(short flags) { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - public static boolean isForcedUsAsciiEncoding(short flags) { - return (flags & FORCED_US_ASCII_ENCODING) != 0; - } - - private final short flags; - - public RegularExpressionFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof RegularExpressionFlags)) { - return false; - } - - return flags == ((RegularExpressionFlags) other).flags; - } - - @Override - public int compareTo(RegularExpressionFlags other) { - return flags - other.flags; - } - - public boolean isIgnoreCase() { - return (flags & IGNORE_CASE) != 0; - } - - public boolean isExtended() { - return (flags & EXTENDED) != 0; - } - - public boolean isMultiLine() { - return (flags & MULTI_LINE) != 0; - } - - public boolean isOnce() { - return (flags & ONCE) != 0; - } - - public boolean isEucJp() { - return (flags & EUC_JP) != 0; - } - - public boolean isAscii8bit() { - return (flags & ASCII_8BIT) != 0; - } - - public boolean isWindows31j() { - return (flags & WINDOWS_31J) != 0; - } - - public boolean isUtf8() { - return (flags & UTF_8) != 0; - } - - public boolean isForcedUtf8Encoding() { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public boolean isForcedBinaryEncoding() { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - public boolean isForcedUsAsciiEncoding() { - return (flags & FORCED_US_ASCII_ENCODING) != 0; - } - - } - - /** - * Flags for shareable constant nodes. - */ - public static final class ShareableConstantNodeFlags implements Comparable { - - // constant writes that should be modified with shareable constant value literal - public static final short LITERAL = 1 << 2; - - // constant writes that should be modified with shareable constant value experimental everything - public static final short EXPERIMENTAL_EVERYTHING = 1 << 3; - - // constant writes that should be modified with shareable constant value experimental copy - public static final short EXPERIMENTAL_COPY = 1 << 4; - - public static boolean isLiteral(short flags) { - return (flags & LITERAL) != 0; - } - - public static boolean isExperimentalEverything(short flags) { - return (flags & EXPERIMENTAL_EVERYTHING) != 0; - } - - public static boolean isExperimentalCopy(short flags) { - return (flags & EXPERIMENTAL_COPY) != 0; - } - - private final short flags; - - public ShareableConstantNodeFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof ShareableConstantNodeFlags)) { - return false; - } - - return flags == ((ShareableConstantNodeFlags) other).flags; - } - - @Override - public int compareTo(ShareableConstantNodeFlags other) { - return flags - other.flags; - } - - public boolean isLiteral() { - return (flags & LITERAL) != 0; - } - - public boolean isExperimentalEverything() { - return (flags & EXPERIMENTAL_EVERYTHING) != 0; - } - - public boolean isExperimentalCopy() { - return (flags & EXPERIMENTAL_COPY) != 0; - } - - } - - /** - * Flags for string nodes. - */ - public static final class StringFlags implements Comparable { - - // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 2; - - // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 3; - - // frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal` - public static final short FROZEN = 1 << 4; - - // mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` - public static final short MUTABLE = 1 << 5; - - public static boolean isForcedUtf8Encoding(short flags) { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public static boolean isForcedBinaryEncoding(short flags) { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - public static boolean isFrozen(short flags) { - return (flags & FROZEN) != 0; - } - - public static boolean isMutable(short flags) { - return (flags & MUTABLE) != 0; - } - - private final short flags; - - public StringFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof StringFlags)) { - return false; - } - - return flags == ((StringFlags) other).flags; - } - - @Override - public int compareTo(StringFlags other) { - return flags - other.flags; - } - - public boolean isForcedUtf8Encoding() { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public boolean isForcedBinaryEncoding() { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - public boolean isFrozen() { - return (flags & FROZEN) != 0; - } - - public boolean isMutable() { - return (flags & MUTABLE) != 0; - } - - } - - /** - * Flags for symbol nodes. - */ - public static final class SymbolFlags implements Comparable { - - // internal bytes forced the encoding to UTF-8 - public static final short FORCED_UTF8_ENCODING = 1 << 2; - - // internal bytes forced the encoding to binary - public static final short FORCED_BINARY_ENCODING = 1 << 3; - - // internal bytes forced the encoding to US-ASCII - public static final short FORCED_US_ASCII_ENCODING = 1 << 4; - - public static boolean isForcedUtf8Encoding(short flags) { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public static boolean isForcedBinaryEncoding(short flags) { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - public static boolean isForcedUsAsciiEncoding(short flags) { - return (flags & FORCED_US_ASCII_ENCODING) != 0; - } - - private final short flags; - - public SymbolFlags(short flags) { - this.flags = flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public boolean equals(Object other) { - if (!(other instanceof SymbolFlags)) { - return false; - } - - return flags == ((SymbolFlags) other).flags; - } - - @Override - public int compareTo(SymbolFlags other) { - return flags - other.flags; - } - - public boolean isForcedUtf8Encoding() { - return (flags & FORCED_UTF8_ENCODING) != 0; - } - - public boolean isForcedBinaryEncoding() { - return (flags & FORCED_BINARY_ENCODING) != 0; - } - - public boolean isForcedUsAsciiEncoding() { - return (flags & FORCED_US_ASCII_ENCODING) != 0; - } - - } - - /** - * 
-     * Represents the use of the `alias` keyword to alias a global variable.
-     *
-     *     alias $foo $bar
-     *     ^^^^^^^^^^^^^^^
-     *
- */ - public static final class AliasGlobalVariableNode extends Node { - /** - * 
-         * Represents the new name of the global variable that can be used after aliasing.
-         *
-         *     alias $foo $bar
-         *           ^^^^
-         *
- */ - @UnionType({ GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class }) - public final Node new_name; - /** - * 
-         * Represents the old name of the global variable that can be used before aliasing.
-         *
-         *     alias $foo $bar
-         *                ^^^^
-         *
- */ - @UnionType({ GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class }) - public final Node old_name; - - public AliasGlobalVariableNode(int startOffset, int length, Node new_name, Node old_name) { - super(startOffset, length); - this.new_name = new_name; - this.old_name = old_name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.new_name.accept(visitor); - this.old_name.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.new_name, this.old_name }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitAliasGlobalVariableNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("new_name: "); - builder.append(this.new_name.toString(nextIndent)); - builder.append(nextIndent); - builder.append("old_name: "); - builder.append(this.old_name.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `alias` keyword to alias a method.
-     *
-     *     alias foo bar
-     *     ^^^^^^^^^^^^^
-     *
- */ - public static final class AliasMethodNode extends Node { - /** - * 
-         * Represents the new name of the method that will be aliased.
-         *
-         *     alias foo bar
-         *           ^^^
-         *
-         *     alias :foo :bar
-         *           ^^^^
-         *
-         *     alias :"#{foo}" :"#{bar}"
-         *           ^^^^^^^^^
-         *
- */ - @UnionType({ SymbolNode.class, InterpolatedSymbolNode.class }) - public final Node new_name; - /** - * 
-         * Represents the old name of the method that will be aliased.
-         *
-         *     alias foo bar
-         *               ^^^
-         *
-         *     alias :foo :bar
-         *                ^^^^
-         *
-         *     alias :"#{foo}" :"#{bar}"
-         *                     ^^^^^^^^^
-         *
- */ - @UnionType({ SymbolNode.class, InterpolatedSymbolNode.class }) - public final Node old_name; - - public AliasMethodNode(int startOffset, int length, Node new_name, Node old_name) { - super(startOffset, length); - this.new_name = new_name; - this.old_name = old_name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.new_name.accept(visitor); - this.old_name.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.new_name, this.old_name }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitAliasMethodNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("new_name: "); - builder.append(this.new_name.toString(nextIndent)); - builder.append(nextIndent); - builder.append("old_name: "); - builder.append(this.old_name.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an alternation pattern in pattern matching.
-     *
-     *     foo => bar | baz
-     *            ^^^^^^^^^
-     *
- */ - public static final class AlternationPatternNode extends Node { - /** - * 
-         * Represents the left side of the expression.
-         *
-         *     foo => bar | baz
-         *            ^^^
-         *
- */ - public final Node left; - /** - * 
-         * Represents the right side of the expression.
-         *
-         *     foo => bar | baz
-         *                  ^^^
-         *
- */ - public final Node right; - - public AlternationPatternNode(int startOffset, int length, Node left, Node right) { - super(startOffset, length); - this.left = left; - this.right = right; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.left.accept(visitor); - this.right.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.left, this.right }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitAlternationPatternNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("left: "); - builder.append(this.left.toString(nextIndent)); - builder.append(nextIndent); - builder.append("right: "); - builder.append(this.right.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&` operator or the `and` keyword.
-     *
-     *     left and right
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class AndNode extends Node { - /** - * 
-         * Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     left and right
-         *     ^^^^
-         *
-         *     1 && 2
-         *     ^
-         *
- */ - public final Node left; - /** - * 
-         * Represents the right side of the expression.
-         *
-         *     left && right
-         *             ^^^^^
-         *
-         *     1 and 2
-         *           ^
-         *
- */ - public final Node right; - - public AndNode(int startOffset, int length, Node left, Node right) { - super(startOffset, length); - this.left = left; - this.right = right; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.left.accept(visitor); - this.right.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.left, this.right }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitAndNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("left: "); - builder.append(this.left.toString(nextIndent)); - builder.append(nextIndent); - builder.append("right: "); - builder.append(this.right.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a set of arguments to a method or a keyword.
-     *
-     *     return foo, bar, baz
-     *            ^^^^^^^^^^^^^
-     *
- */ - public static final class ArgumentsNode extends Node { - public final short flags; - /** - * 
-         * The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo(bar, baz)
-         *         ^^^^^^^^
-         *
- */ - public final Node[] arguments; - - public ArgumentsNode(int startOffset, int length, short flags, Node[] arguments) { - super(startOffset, length); - this.flags = flags; - this.arguments = arguments; - } - - public boolean isContainsForwarding() { - return ArgumentsNodeFlags.isContainsForwarding(flags); - } - - public boolean isContainsKeywords() { - return ArgumentsNodeFlags.isContainsKeywords(flags); - } - - public boolean isContainsKeywordSplat() { - return ArgumentsNodeFlags.isContainsKeywordSplat(flags); - } - - public boolean isContainsSplat() { - return ArgumentsNodeFlags.isContainsSplat(flags); - } - - public boolean isContainsMultipleSplats() { - return ArgumentsNodeFlags.isContainsMultipleSplats(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.arguments) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.arguments)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitArgumentsNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("ArgumentsNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("arguments: "); - builder.append('\n'); - for (Node child : this.arguments) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
-     *
-     *     [1, 2, 3]
-     *     ^^^^^^^^^
-     *
- */ - public static final class ArrayNode extends Node { - public final short flags; - /** - * 
-         * Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
-         *
- */ - public final Node[] elements; - - public ArrayNode(int startOffset, int length, short flags, Node[] elements) { - super(startOffset, length); - this.flags = flags; - this.elements = elements; - } - - public boolean isContainsSplat() { - return ArrayNodeFlags.isContainsSplat(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.elements) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.elements)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitArrayNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("ArrayNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("elements: "); - builder.append('\n'); - for (Node child : this.elements) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents an array pattern in pattern matching.
-     *
-     *     foo in 1, 2
-     *     ^^^^^^^^^^^
-     *
-     *     foo in [1, 2]
-     *     ^^^^^^^^^^^^^
-     *
-     *     foo in *bar
-     *     ^^^^^^^^^^^
-     *
-     *     foo in Bar[]
-     *     ^^^^^^^^^^^^
-     *
-     *     foo in Bar[1, 2, 3]
-     *     ^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ArrayPatternNode extends Node { - @Nullable - @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) - public final Node constant; - /** - * 
-         * Represents the required elements of the array pattern.
-         *
-         *     foo in [1, 2]
-         *             ^  ^
-         *
- */ - public final Node[] requireds; - /** - * 
-         * Represents the rest element of the array pattern.
-         *
-         *     foo in *bar
-         *            ^^^^
-         *
- */ - @Nullable - public final Node rest; - /** - * 
-         * Represents the elements after the rest element of the array pattern.
-         *
-         *     foo in *bar, baz
-         *                  ^^^
-         *
- */ - public final Node[] posts; - - public ArrayPatternNode(int startOffset, int length, Node constant, Node[] requireds, Node rest, Node[] posts) { - super(startOffset, length); - this.constant = constant; - this.requireds = requireds; - this.rest = rest; - this.posts = posts; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.constant != null) { - this.constant.accept(visitor); - } - for (Nodes.Node child : this.requireds) { - child.accept(visitor); - } - if (this.rest != null) { - this.rest.accept(visitor); - } - for (Nodes.Node child : this.posts) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.add(this.constant); - childNodes.addAll(Arrays.asList(this.requireds)); - childNodes.add(this.rest); - childNodes.addAll(Arrays.asList(this.posts)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitArrayPatternNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("constant: "); - builder.append(this.constant == null ? "null\n" : this.constant.toString(nextIndent)); - builder.append(nextIndent); - builder.append("requireds: "); - builder.append('\n'); - for (Node child : this.requireds) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("rest: "); - builder.append(this.rest == null ? "null\n" : this.rest.toString(nextIndent)); - builder.append(nextIndent); - builder.append("posts: "); - builder.append('\n'); - for (Node child : this.posts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a hash key/value pair.
-     *
-     *     { a => b }
-     *       ^^^^^^
-     *
- */ - public static final class AssocNode extends Node { - /** - * 
-         * The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     { a: b }
-         *       ^
-         *
-         *     { foo => bar }
-         *       ^^^
-         *
-         *     { def a; end => 1 }
-         *       ^^^^^^^^^^
-         *
- */ - public final Node key; - /** - * 
-         * The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     { foo => bar }
-         *              ^^^
-         *
-         *     { x: 1 }
-         *          ^
-         *
- */ - public final Node value; - - public AssocNode(int startOffset, int length, Node key, Node value) { - super(startOffset, length); - this.key = key; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.key.accept(visitor); - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.key, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitAssocNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("key: "); - builder.append(this.key.toString(nextIndent)); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a splat in a hash literal.
-     *
-     *     { **foo }
-     *       ^^^^^
-     *
- */ - public static final class AssocSplatNode extends Node { - /** - * 
-         * The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
-         *
-         *     { **foo }
-         *         ^^^
-         *
- */ - @Nullable - public final Node value; - - public AssocSplatNode(int startOffset, int length, Node value) { - super(startOffset, length); - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.value != null) { - this.value.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitAssocSplatNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value == null ? "null\n" : this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents reading a reference to a field in the previous match.
-     *
-     *     $'
-     *     ^^
-     *
- */ - public static final class BackReferenceReadNode extends Node { - /** - * 
-         * The name of the back-reference variable, including the leading `$`.
-         *
-         *     $& # name `:$&`
-         *
-         *     $+ # name `:$+`
-         *
- */ - public final org.jruby.RubySymbol name; - - public BackReferenceReadNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBackReferenceReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents a begin statement.
-     *
-     *     begin
-     *       foo
-     *     end
-     *     ^^^^^
-     *
- */ - public static final class BeginNode extends Node { - /** - * 
-         * Represents the statements within the begin block.
-         *
-         *     begin x end
-         *           ^
-         *
- */ - @Nullable - public final StatementsNode statements; - /** - * 
-         * Represents the rescue clause within the begin block.
-         *
-         *     begin x; rescue y; end
-         *              ^^^^^^^^
-         *
- */ - @Nullable - public final RescueNode rescue_clause; - /** - * 
-         * Represents the else clause within the begin block.
-         *
-         *     begin x; rescue y; else z; end
-         *                        ^^^^^^
-         *
- */ - @Nullable - public final ElseNode else_clause; - /** - * 
-         * Represents the ensure clause within the begin block.
-         *
-         *     begin x; ensure y; end
-         *              ^^^^^^^^
-         *
- */ - @Nullable - public final EnsureNode ensure_clause; - - public BeginNode(int startOffset, int length, StatementsNode statements, RescueNode rescue_clause, ElseNode else_clause, EnsureNode ensure_clause) { - super(startOffset, length); - this.statements = statements; - this.rescue_clause = rescue_clause; - this.else_clause = else_clause; - this.ensure_clause = ensure_clause; - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - // Never mark BeginNode with a newline flag, mark children instead - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.statements != null) { - this.statements.accept(visitor); - } - if (this.rescue_clause != null) { - this.rescue_clause.accept(visitor); - } - if (this.else_clause != null) { - this.else_clause.accept(visitor); - } - if (this.ensure_clause != null) { - this.ensure_clause.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.statements, this.rescue_clause, this.else_clause, this.ensure_clause }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBeginNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - builder.append(nextIndent); - builder.append("rescue_clause: "); - builder.append(this.rescue_clause == null ? "null\n" : this.rescue_clause.toString(nextIndent)); - builder.append(nextIndent); - builder.append("else_clause: "); - builder.append(this.else_clause == null ? "null\n" : this.else_clause.toString(nextIndent)); - builder.append(nextIndent); - builder.append("ensure_clause: "); - builder.append(this.ensure_clause == null ? "null\n" : this.ensure_clause.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a block argument using `&`.
-     *
-     *     bar(&args)
-     *     ^^^^^^^^^^
-     *
- */ - public static final class BlockArgumentNode extends Node { - /** - * 
-         * The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo(&args)
-         *         ^^^^^
-         *
- */ - @Nullable - public final Node expression; - - public BlockArgumentNode(int startOffset, int length, Node expression) { - super(startOffset, length); - this.expression = expression; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.expression != null) { - this.expression.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.expression }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBlockArgumentNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("expression: "); - builder.append(this.expression == null ? "null\n" : this.expression.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a block local variable.
-     *
-     *     a { |; b| }
-     *            ^
-     *
- */ - public static final class BlockLocalVariableNode extends Node { - public final short flags; - /** - * 
-         * The name of the block local variable.
-         *
-         *     a { |; b| } # name `:b`
-         *            ^
-         *
- */ - public final org.jruby.RubySymbol name; - - public BlockLocalVariableNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { - super(startOffset, length); - this.flags = flags; - this.name = name; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBlockLocalVariableNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents a block of ruby code.
-     *
-     *     [1, 2, 3].each { |i| puts x }
-     *                    ^^^^^^^^^^^^^^
-     *
- */ - public static final class BlockNode extends Node { - /** - * 
-         * The local variables declared in the block.
-         *
-         *     [1, 2, 3].each { |i| puts x } # locals: [:i]
-         *                       ^
-         *
- */ - public final org.jruby.RubySymbol[] locals; - /** - * 
-         * The parameters of the block.
-         *
-         *     [1, 2, 3].each { |i| puts x }
-         *                      ^^^
-         *     [1, 2, 3].each { puts _1 }
-         *                    ^^^^^^^^^^^
-         *     [1, 2, 3].each { puts it }
-         *                    ^^^^^^^^^^^
-         *
- */ - @Nullable - @UnionType({ BlockParametersNode.class, NumberedParametersNode.class, ItParametersNode.class }) - public final Node parameters; - /** - * 
-         * The body of the block.
-         *
-         *     [1, 2, 3].each { |i| puts x }
-         *                          ^^^^^^
-         *
- */ - @Nullable - @UnionType({ StatementsNode.class, BeginNode.class }) - public final Node body; - - public BlockNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node parameters, Node body) { - super(startOffset, length); - this.locals = locals; - this.parameters = parameters; - this.body = body; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.parameters != null) { - this.parameters.accept(visitor); - } - if (this.body != null) { - this.body.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.parameters, this.body }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBlockNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (org.jruby.RubySymbol constant : this.locals) { - builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n'); - } - builder.append(nextIndent); - builder.append("parameters: "); - builder.append(this.parameters == null ? "null\n" : this.parameters.toString(nextIndent)); - builder.append(nextIndent); - builder.append("body: "); - builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a block parameter of a method, block, or lambda definition.
-     *
-     *     def a(&b)
-     *           ^^
-     *     end
-     *
- */ - public static final class BlockParameterNode extends Node { - public final short flags; - /** - * 
-         * The name of the block parameter.
-         *
-         *     def a(&b) # name `:b`
-         *            ^
-         *     end
-         *
- */ - @Nullable - public final org.jruby.RubySymbol name; - - public BlockParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { - super(startOffset, length); - this.flags = flags; - this.name = name; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBlockParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append(this.name == null ? "null" : "\"" + this.name + "\""); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents a block's parameters declaration.
-     *
-     *     -> (a, b = 1; local) { }
-     *        ^^^^^^^^^^^^^^^^^
-     *
-     *     foo do |a, b = 1; local|
-     *            ^^^^^^^^^^^^^^^^^
-     *     end
-     *
- */ - public static final class BlockParametersNode extends Node { - /** - * 
-         * Represents the parameters of the block.
-         *
-         *     -> (a, b = 1; local) { }
-         *         ^^^^^^^^
-         *
-         *     foo do |a, b = 1; local|
-         *             ^^^^^^^^
-         *     end
-         *
- */ - @Nullable - public final ParametersNode parameters; - /** - * 
-         * Represents the local variables of the block.
-         *
-         *     -> (a, b = 1; local) { }
-         *                   ^^^^^
-         *
-         *     foo do |a, b = 1; local|
-         *                       ^^^^^
-         *     end
-         *
- */ - public final BlockLocalVariableNode[] locals; - - public BlockParametersNode(int startOffset, int length, ParametersNode parameters, BlockLocalVariableNode[] locals) { - super(startOffset, length); - this.parameters = parameters; - this.locals = locals; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.parameters != null) { - this.parameters.accept(visitor); - } - for (Nodes.Node child : this.locals) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.add(this.parameters); - childNodes.addAll(Arrays.asList(this.locals)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBlockParametersNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("parameters: "); - builder.append(this.parameters == null ? "null\n" : this.parameters.toString(nextIndent)); - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (Node child : this.locals) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `break` keyword.
-     *
-     *     break foo
-     *     ^^^^^^^^^
-     *
- */ - public static final class BreakNode extends Node { - /** - * 
-         * The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     break foo
-         *           ^^^
-         *
- */ - @Nullable - public final ArgumentsNode arguments; - - public BreakNode(int startOffset, int length, ArgumentsNode arguments) { - super(startOffset, length); - this.arguments = arguments; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.arguments != null) { - this.arguments.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.arguments }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitBreakNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator on a call.
-     *
-     *     foo.bar &&= value
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class CallAndWriteNode extends Node { - public final short flags; - /** - * 
-         * The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo.bar &&= value
-         *     ^^^
-         *
- */ - @Nullable - public final Node receiver; - /** - * 
-         * Represents the name of the method being called.
-         *
-         *     foo.bar &&= value # read_name `:bar`
-         *         ^^^
-         *
- */ - public final org.jruby.RubySymbol read_name; - /** - * 
-         * Represents the name of the method being written to.
-         *
-         *     foo.bar &&= value # write_name `:bar=`
-         *         ^^^
-         *
- */ - public final org.jruby.RubySymbol write_name; - /** - * 
-         * Represents the value being assigned.
-         *
-         *     foo.bar &&= value
-         *                 ^^^^^
-         *
- */ - public final Node value; - - public CallAndWriteNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, Node value) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.read_name = read_name; - this.write_name = write_name; - this.value = value; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCallAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("read_name: "); - builder.append('"').append(this.read_name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("write_name: "); - builder.append('"').append(this.write_name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a method call, in all of the various forms that can take.
-     *
-     *     foo
-     *     ^^^
-     *
-     *     foo()
-     *     ^^^^^
-     *
-     *     +foo
-     *     ^^^^
-     *
-     *     foo + bar
-     *     ^^^^^^^^^
-     *
-     *     foo.bar
-     *     ^^^^^^^
-     *
-     *     foo&.bar
-     *     ^^^^^^^^
-     *
- */ - public static final class CallNode extends Node { - public final short flags; - /** - * 
-         * The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo.bar
-         *     ^^^
-         *
-         *     +foo
-         *      ^^^
-         *
-         *     foo + bar
-         *     ^^^
-         *
- */ - @Nullable - public final Node receiver; - /** - * 
-         * Represents the name of the method being called.
-         *
-         *     foo.bar # name `:foo`
-         *     ^^^
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo(bar)
-         *         ^^^
-         *
- */ - @Nullable - public final ArgumentsNode arguments; - /** - * 
-         * Represents the block that is being passed to the method.
-         *
-         *     foo { |a| a }
-         *         ^^^^^^^^^
-         *
- */ - @Nullable - @UnionType({ BlockNode.class, BlockArgumentNode.class }) - public final Node block; - - public CallNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol name, ArgumentsNode arguments, Node block) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.name = name; - this.arguments = arguments; - this.block = block; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - if (this.arguments != null) { - this.arguments.accept(visitor); - } - if (this.block != null) { - this.block.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.arguments, this.block }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCallNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of an assignment operator on a call.
-     *
-     *     foo.bar += baz
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class CallOperatorWriteNode extends Node { - public final short flags; - /** - * 
-         * The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo.bar += value
-         *     ^^^
-         *
- */ - @Nullable - public final Node receiver; - /** - * 
-         * Represents the name of the method being called.
-         *
-         *     foo.bar += value # read_name `:bar`
-         *         ^^^
-         *
- */ - public final org.jruby.RubySymbol read_name; - /** - * 
-         * Represents the name of the method being written to.
-         *
-         *     foo.bar += value # write_name `:bar=`
-         *         ^^^
-         *
- */ - public final org.jruby.RubySymbol write_name; - /** - * 
-         * Represents the binary operator being used.
-         *
-         *     foo.bar += value # binary_operator `:+`
-         *             ^
-         *
- */ - public final org.jruby.RubySymbol binary_operator; - /** - * 
-         * Represents the value being assigned.
-         *
-         *     foo.bar += value
-         *                ^^^^^
-         *
- */ - public final Node value; - - public CallOperatorWriteNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, org.jruby.RubySymbol binary_operator, Node value) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.read_name = read_name; - this.write_name = write_name; - this.binary_operator = binary_operator; - this.value = value; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCallOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("read_name: "); - builder.append('"').append(this.read_name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("write_name: "); - builder.append('"').append(this.write_name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator on a call.
-     *
-     *     foo.bar ||= value
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class CallOrWriteNode extends Node { - public final short flags; - /** - * 
-         * The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo.bar ||= value
-         *     ^^^
-         *
- */ - @Nullable - public final Node receiver; - /** - * 
-         * Represents the name of the method being called.
-         *
-         *     foo.bar ||= value # read_name `:bar`
-         *         ^^^
-         *
- */ - public final org.jruby.RubySymbol read_name; - /** - * 
-         * Represents the name of the method being written to.
-         *
-         *     foo.bar ||= value # write_name `:bar=`
-         *         ^^^
-         *
- */ - public final org.jruby.RubySymbol write_name; - /** - * 
-         * Represents the value being assigned.
-         *
-         *     foo.bar ||= value
-         *                 ^^^^^
-         *
- */ - public final Node value; - - public CallOrWriteNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol read_name, org.jruby.RubySymbol write_name, Node value) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.read_name = read_name; - this.write_name = write_name; - this.value = value; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCallOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("read_name: "); - builder.append('"').append(this.read_name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("write_name: "); - builder.append('"').append(this.write_name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to a method call.
-     *
-     *     foo.bar, = 1
-     *     ^^^^^^^
-     *
-     *     begin
-     *     rescue => foo.bar
-     *               ^^^^^^^
-     *     end
-     *
-     *     for foo.bar in baz do end
-     *         ^^^^^^^
-     *
- */ - public static final class CallTargetNode extends Node { - public final short flags; - /** - * 
-         * The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo.bar = 1
-         *     ^^^
-         *
- */ - public final Node receiver; - /** - * 
-         * Represents the name of the method being called.
-         *
-         *     foo.bar = 1 # name `:foo`
-         *     ^^^
-         *
- */ - public final org.jruby.RubySymbol name; - - public CallTargetNode(int startOffset, int length, short flags, Node receiver, org.jruby.RubySymbol name) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.name = name; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.receiver.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.receiver }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCallTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to a local variable in pattern matching.
-     *
-     *     foo => [bar => baz]
-     *            ^^^^^^^^^^^^
-     *
- */ - public static final class CapturePatternNode extends Node { - /** - * 
-         * Represents the value to capture.
-         *
-         *     foo => bar
-         *            ^^^
-         *
- */ - public final Node value; - /** - * 
-         * Represents the target of the capture.
-         *
-         *     foo => bar
-         *     ^^^
-         *
- */ - public final LocalVariableTargetNode target; - - public CapturePatternNode(int startOffset, int length, Node value, LocalVariableTargetNode target) { - super(startOffset, length); - this.value = value; - this.target = target; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - this.target.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value, this.target }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCapturePatternNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("target: "); - builder.append(this.target.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of a case statement for pattern matching.
-     *
-     *     case true
-     *     in false
-     *     end
-     *     ^^^^^^^^^
-     *
- */ - public static final class CaseMatchNode extends Node { - /** - * 
-         * Represents the predicate of the case match. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     case true; in false; end
-         *     ^^^^
-         *
- */ - @Nullable - public final Node predicate; - /** - * 
-         * Represents the conditions of the case match.
-         *
-         *     case true; in false; end
-         *                ^^^^^^^^
-         *
- */ - public final InNode[] conditions; - /** - * 
-         * Represents the else clause of the case match.
-         *
-         *     case true; in false; else; end
-         *                          ^^^^
-         *
- */ - @Nullable - public final ElseNode else_clause; - - public CaseMatchNode(int startOffset, int length, Node predicate, InNode[] conditions, ElseNode else_clause) { - super(startOffset, length); - this.predicate = predicate; - this.conditions = conditions; - this.else_clause = else_clause; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.predicate != null) { - this.predicate.accept(visitor); - } - for (Nodes.Node child : this.conditions) { - child.accept(visitor); - } - if (this.else_clause != null) { - this.else_clause.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.add(this.predicate); - childNodes.addAll(Arrays.asList(this.conditions)); - childNodes.add(this.else_clause); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCaseMatchNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("predicate: "); - builder.append(this.predicate == null ? "null\n" : this.predicate.toString(nextIndent)); - builder.append(nextIndent); - builder.append("conditions: "); - builder.append('\n'); - for (Node child : this.conditions) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("else_clause: "); - builder.append(this.else_clause == null ? "null\n" : this.else_clause.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of a case statement.
-     *
-     *     case true
-     *     when false
-     *     end
-     *     ^^^^^^^^^^
-     *
- */ - public static final class CaseNode extends Node { - /** - * 
-         * Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     case true; when false; end
-         *     ^^^^
-         *
- */ - @Nullable - public final Node predicate; - /** - * 
-         * Represents the conditions of the case statement.
-         *
-         *     case true; when false; end
-         *                ^^^^^^^^^^
-         *
- */ - public final WhenNode[] conditions; - /** - * 
-         * Represents the else clause of the case statement.
-         *
-         *     case true; when false; else; end
-         *                            ^^^^
-         *
- */ - @Nullable - public final ElseNode else_clause; - - public CaseNode(int startOffset, int length, Node predicate, WhenNode[] conditions, ElseNode else_clause) { - super(startOffset, length); - this.predicate = predicate; - this.conditions = conditions; - this.else_clause = else_clause; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.predicate != null) { - this.predicate.accept(visitor); - } - for (Nodes.Node child : this.conditions) { - child.accept(visitor); - } - if (this.else_clause != null) { - this.else_clause.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.add(this.predicate); - childNodes.addAll(Arrays.asList(this.conditions)); - childNodes.add(this.else_clause); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitCaseNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("predicate: "); - builder.append(this.predicate == null ? "null\n" : this.predicate.toString(nextIndent)); - builder.append(nextIndent); - builder.append("conditions: "); - builder.append('\n'); - for (Node child : this.conditions) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("else_clause: "); - builder.append(this.else_clause == null ? "null\n" : this.else_clause.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a class declaration involving the `class` keyword.
-     *
-     *     class Foo end
-     *     ^^^^^^^^^^^^^
-     *
- */ - public static final class ClassNode extends Node { - public final org.jruby.RubySymbol[] locals; - @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) - public final Node constant_path; - @Nullable - public final Node superclass; - @Nullable - @UnionType({ StatementsNode.class, BeginNode.class }) - public final Node body; - public final org.jruby.RubySymbol name; - - public ClassNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node constant_path, Node superclass, Node body, org.jruby.RubySymbol name) { - super(startOffset, length); - this.locals = locals; - this.constant_path = constant_path; - this.superclass = superclass; - this.body = body; - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.constant_path.accept(visitor); - if (this.superclass != null) { - this.superclass.accept(visitor); - } - if (this.body != null) { - this.body.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.constant_path, this.superclass, this.body }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitClassNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (org.jruby.RubySymbol constant : this.locals) { - builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n'); - } - builder.append(nextIndent); - builder.append("constant_path: "); - builder.append(this.constant_path.toString(nextIndent)); - builder.append(nextIndent); - builder.append("superclass: "); - builder.append(this.superclass == null ? "null\n" : this.superclass.toString(nextIndent)); - builder.append(nextIndent); - builder.append("body: "); - builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator for assignment to a class variable.
-     *
-     *     @@target &&= value
-     *     ^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ClassVariableAndWriteNode extends Node { - /** - * 
-         * The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-         *
-         *     @@target &&= value # name `:@@target`
-         *     ^^^^^^^^
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     @@target &&= value
-         *                  ^^^^^
-         *
- */ - public final Node value; - - public ClassVariableAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitClassVariableAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to a class variable using an operator that isn't `=`.
-     *
-     *     @@target += value
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ClassVariableOperatorWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - public final org.jruby.RubySymbol binary_operator; - - public ClassVariableOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { - super(startOffset, length); - this.name = name; - this.value = value; - this.binary_operator = binary_operator; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitClassVariableOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator for assignment to a class variable.
-     *
-     *     @@target ||= value
-     *     ^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ClassVariableOrWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - - public ClassVariableOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitClassVariableOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents referencing a class variable.
-     *
-     *     @@foo
-     *     ^^^^^
-     *
- */ - public static final class ClassVariableReadNode extends Node { - /** - * 
-         * The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-         *
-         *     @@abc   # name `:@@abc`
-         *
-         *     @@_test # name `:@@_test`
-         *
- */ - public final org.jruby.RubySymbol name; - - public ClassVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitClassVariableReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a class variable in a context that doesn't have an explicit value.
-     *
-     *     @@foo, @@bar = baz
-     *     ^^^^^  ^^^^^
-     *
- */ - public static final class ClassVariableTargetNode extends Node { - public final org.jruby.RubySymbol name; - - public ClassVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitClassVariableTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a class variable.
-     *
-     *     @@foo = 1
-     *     ^^^^^^^^^
-     *
- */ - public static final class ClassVariableWriteNode extends Node { - /** - * 
-         * The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-         *
-         *     @@abc = 123     # name `@@abc`
-         *
-         *     @@_test = :test # name `@@_test`
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     @@foo = :bar
-         *             ^^^^
-         *
-         *     @@_xyz = 123
-         *              ^^^
-         *
- */ - public final Node value; - - public ClassVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitClassVariableWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator for assignment to a constant.
-     *
-     *     Target &&= value
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ConstantAndWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - - public ConstantAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to a constant using an operator that isn't `=`.
-     *
-     *     Target += value
-     *     ^^^^^^^^^^^^^^^
-     *
- */ - public static final class ConstantOperatorWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - public final org.jruby.RubySymbol binary_operator; - - public ConstantOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { - super(startOffset, length); - this.name = name; - this.value = value; - this.binary_operator = binary_operator; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator for assignment to a constant.
-     *
-     *     Target ||= value
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ConstantOrWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - - public ConstantOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator for assignment to a constant path.
-     *
-     *     Parent::Child &&= value
-     *     ^^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ConstantPathAndWriteNode extends Node { - public final ConstantPathNode target; - public final Node value; - - public ConstantPathAndWriteNode(int startOffset, int length, ConstantPathNode target, Node value) { - super(startOffset, length); - this.target = target; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.target.accept(visitor); - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.target, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantPathAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("target: "); - builder.append(this.target.toString(nextIndent)); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents accessing a constant through a path of `::` operators.
-     *
-     *     Foo::Bar
-     *     ^^^^^^^^
-     *
- */ - public static final class ConstantPathNode extends Node { - /** - * 
-         * The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
-         *
-         *     Foo::Bar
-         *     ^^^
-         *
-         *     self::Test
-         *     ^^^^
-         *
-         *     a.b::C
-         *     ^^^
-         *
- */ - @Nullable - public final Node parent; - /** - * 
-         * The name of the constant being accessed. This could be `nil` in the event of a syntax error.
-         *
- */ - @Nullable - public final org.jruby.RubySymbol name; - - public ConstantPathNode(int startOffset, int length, Node parent, org.jruby.RubySymbol name) { - super(startOffset, length); - this.parent = parent; - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.parent != null) { - this.parent.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.parent }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantPathNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("parent: "); - builder.append(this.parent == null ? "null\n" : this.parent.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append(this.name == null ? "null" : "\"" + this.name + "\""); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to a constant path using an operator that isn't `=`.
-     *
-     *     Parent::Child += value
-     *     ^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ConstantPathOperatorWriteNode extends Node { - public final ConstantPathNode target; - public final Node value; - public final org.jruby.RubySymbol binary_operator; - - public ConstantPathOperatorWriteNode(int startOffset, int length, ConstantPathNode target, Node value, org.jruby.RubySymbol binary_operator) { - super(startOffset, length); - this.target = target; - this.value = value; - this.binary_operator = binary_operator; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.target.accept(visitor); - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.target, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantPathOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("target: "); - builder.append(this.target.toString(nextIndent)); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator for assignment to a constant path.
-     *
-     *     Parent::Child ||= value
-     *     ^^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class ConstantPathOrWriteNode extends Node { - public final ConstantPathNode target; - public final Node value; - - public ConstantPathOrWriteNode(int startOffset, int length, ConstantPathNode target, Node value) { - super(startOffset, length); - this.target = target; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.target.accept(visitor); - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.target, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantPathOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("target: "); - builder.append(this.target.toString(nextIndent)); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a constant path in a context that doesn't have an explicit value.
-     *
-     *     Foo::Foo, Bar::Bar = baz
-     *     ^^^^^^^^  ^^^^^^^^
-     *
- */ - public static final class ConstantPathTargetNode extends Node { - @Nullable - public final Node parent; - @Nullable - public final org.jruby.RubySymbol name; - - public ConstantPathTargetNode(int startOffset, int length, Node parent, org.jruby.RubySymbol name) { - super(startOffset, length); - this.parent = parent; - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.parent != null) { - this.parent.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.parent }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantPathTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("parent: "); - builder.append(this.parent == null ? "null\n" : this.parent.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append(this.name == null ? "null" : "\"" + this.name + "\""); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a constant path.
-     *
-     *     ::Foo = 1
-     *     ^^^^^^^^^
-     *
-     *     Foo::Bar = 1
-     *     ^^^^^^^^^^^^
-     *
-     *     ::Foo::Bar = 1
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class ConstantPathWriteNode extends Node { - /** - * 
-         * A node representing the constant path being written to.
-         *
-         *     Foo::Bar = 1
-         *     ^^^^^^^^
-         *
-         *     ::Foo = :abc
-         *     ^^^^^
-         *
- */ - public final ConstantPathNode target; - /** - * 
-         * The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     FOO::BAR = :abc
-         *                ^^^^
-         *
- */ - public final Node value; - - public ConstantPathWriteNode(int startOffset, int length, ConstantPathNode target, Node value) { - super(startOffset, length); - this.target = target; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.target.accept(visitor); - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.target, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantPathWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("target: "); - builder.append(this.target.toString(nextIndent)); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents referencing a constant.
-     *
-     *     Foo
-     *     ^^^
-     *
- */ - public static final class ConstantReadNode extends Node { - /** - * 
-         * The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
-         *
-         *     X              # name `:X`
-         *
-         *     SOME_CONSTANT  # name `:SOME_CONSTANT`
-         *
- */ - public final org.jruby.RubySymbol name; - - public ConstantReadNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a constant in a context that doesn't have an explicit value.
-     *
-     *     Foo, Bar = baz
-     *     ^^^  ^^^
-     *
- */ - public static final class ConstantTargetNode extends Node { - public final org.jruby.RubySymbol name; - - public ConstantTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a constant.
-     *
-     *     Foo = 1
-     *     ^^^^^^^
-     *
- */ - public static final class ConstantWriteNode extends Node { - /** - * 
-         * The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
-         *
-         *     Foo = :bar # name `:Foo`
-         *
-         *     XYZ = 1    # name `:XYZ`
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     FOO = :bar
-         *           ^^^^
-         *
-         *     MyClass = Class.new
-         *               ^^^^^^^^^
-         *
- */ - public final Node value; - - public ConstantWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitConstantWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a method definition.
-     *
-     *     def method
-     *     end
-     *     ^^^^^^^^^^
-     *
- */ - public static final class DefNode extends Node { - public final int serializedLength; - public final org.jruby.RubySymbol name; - @Nullable - public final Node receiver; - @Nullable - public final ParametersNode parameters; - @Nullable - @UnionType({ StatementsNode.class, BeginNode.class }) - public final Node body; - public final org.jruby.RubySymbol[] locals; - - public DefNode(int startOffset, int length, int serializedLength, org.jruby.RubySymbol name, Node receiver, ParametersNode parameters, Node body, org.jruby.RubySymbol[] locals) { - super(startOffset, length); - this.serializedLength = serializedLength; - this.name = name; - this.receiver = receiver; - this.parameters = parameters; - this.body = body; - this.locals = locals; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - if (this.parameters != null) { - this.parameters.accept(visitor); - } - if (this.body != null) { - this.body.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.parameters, this.body }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitDefNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("parameters: "); - builder.append(this.parameters == null ? "null\n" : this.parameters.toString(nextIndent)); - builder.append(nextIndent); - builder.append("body: "); - builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (org.jruby.RubySymbol constant : this.locals) { - builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n'); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `defined?` keyword.
-     *
-     *     defined?(a)
-     *     ^^^^^^^^^^^
-     *
- */ - public static final class DefinedNode extends Node { - public final Node value; - - public DefinedNode(int startOffset, int length, Node value) { - super(startOffset, length); - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitDefinedNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an `else` clause in a `case`, `if`, or `unless` statement.
-     *
-     *     if a then b else c end
-     *                 ^^^^^^^^^^
-     *
- */ - public static final class ElseNode extends Node { - @Nullable - public final StatementsNode statements; - - public ElseNode(int startOffset, int length, StatementsNode statements) { - super(startOffset, length); - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitElseNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an interpolated set of statements.
-     *
-     *     "foo #{bar}"
-     *          ^^^^^^
-     *
- */ - public static final class EmbeddedStatementsNode extends Node { - @Nullable - public final StatementsNode statements; - - public EmbeddedStatementsNode(int startOffset, int length, StatementsNode statements) { - super(startOffset, length); - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitEmbeddedStatementsNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an interpolated variable.
-     *
-     *     "foo #@bar"
-     *          ^^^^^
-     *
- */ - public static final class EmbeddedVariableNode extends Node { - @UnionType({ InstanceVariableReadNode.class, ClassVariableReadNode.class, GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class }) - public final Node variable; - - public EmbeddedVariableNode(int startOffset, int length, Node variable) { - super(startOffset, length); - this.variable = variable; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.variable.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.variable }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitEmbeddedVariableNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("variable: "); - builder.append(this.variable.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an `ensure` clause in a `begin` statement.
-     *
-     *     begin
-     *       foo
-     *     ensure
-     *     ^^^^^^
-     *       bar
-     *     end
-     *
- */ - public static final class EnsureNode extends Node { - @Nullable - public final StatementsNode statements; - - public EnsureNode(int startOffset, int length, StatementsNode statements) { - super(startOffset, length); - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitEnsureNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the literal `false` keyword.
-     *
-     *     false
-     *     ^^^^^
-     *
- */ - public static final class FalseNode extends Node { - - public FalseNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitFalseNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents a find pattern in pattern matching.
-     *
-     *     foo in *bar, baz, *qux
-     *            ^^^^^^^^^^^^^^^
-     *
-     *     foo in [*bar, baz, *qux]
-     *            ^^^^^^^^^^^^^^^^^
-     *
-     *     foo in Foo(*bar, baz, *qux)
-     *            ^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class FindPatternNode extends Node { - @Nullable - @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) - public final Node constant; - public final SplatNode left; - public final Node[] requireds; - public final SplatNode right; - - public FindPatternNode(int startOffset, int length, Node constant, SplatNode left, Node[] requireds, SplatNode right) { - super(startOffset, length); - this.constant = constant; - this.left = left; - this.requireds = requireds; - this.right = right; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.constant != null) { - this.constant.accept(visitor); - } - this.left.accept(visitor); - for (Nodes.Node child : this.requireds) { - child.accept(visitor); - } - this.right.accept(visitor); - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.add(this.constant); - childNodes.add(this.left); - childNodes.addAll(Arrays.asList(this.requireds)); - childNodes.add(this.right); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitFindPatternNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("constant: "); - builder.append(this.constant == null ? "null\n" : this.constant.toString(nextIndent)); - builder.append(nextIndent); - builder.append("left: "); - builder.append(this.left.toString(nextIndent)); - builder.append(nextIndent); - builder.append("requireds: "); - builder.append('\n'); - for (Node child : this.requireds) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("right: "); - builder.append(this.right.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `..` or `...` operators to create flip flops.
-     *
-     *     baz if foo .. bar
-     *            ^^^^^^^^^^
-     *
- */ - public static final class FlipFlopNode extends Node { - public final short flags; - @Nullable - public final Node left; - @Nullable - public final Node right; - - public FlipFlopNode(int startOffset, int length, short flags, Node left, Node right) { - super(startOffset, length); - this.flags = flags; - this.left = left; - this.right = right; - } - - public boolean isExcludeEnd() { - return RangeFlags.isExcludeEnd(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.left != null) { - this.left.accept(visitor); - } - if (this.right != null) { - this.right.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.left, this.right }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitFlipFlopNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("RangeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("left: "); - builder.append(this.left == null ? "null\n" : this.left.toString(nextIndent)); - builder.append(nextIndent); - builder.append("right: "); - builder.append(this.right == null ? "null\n" : this.right.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a floating point number literal.
-     *
-     *     1.0
-     *     ^^^
-     *
- */ - public static final class FloatNode extends Node { - /** - * 
-         * The value of the floating point number as a Float.
-         *
- */ - public final double value; - - public FloatNode(int startOffset, int length, double value) { - super(startOffset, length); - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitFloatNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `for` keyword.
-     *
-     *     for i in a end
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class ForNode extends Node { - /** - * 
-         * The index expression for `for` loops.
-         *
-         *     for i in a end
-         *         ^
-         *
- */ - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class }) - public final Node index; - /** - * 
-         * The collection to iterate over.
-         *
-         *     for i in a end
-         *              ^
-         *
- */ - public final Node collection; - /** - * 
-         * Represents the body of statements to execute for each iteration of the loop.
-         *
-         *     for i in a
-         *       foo(i)
-         *       ^^^^^^
-         *     end
-         *
- */ - @Nullable - public final StatementsNode statements; - - public ForNode(int startOffset, int length, Node index, Node collection, StatementsNode statements) { - super(startOffset, length); - this.index = index; - this.collection = collection; - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.index.accept(visitor); - this.collection.accept(visitor); - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.index, this.collection, this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitForNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("index: "); - builder.append(this.index.toString(nextIndent)); - builder.append(nextIndent); - builder.append("collection: "); - builder.append(this.collection.toString(nextIndent)); - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents forwarding all arguments to this method to another method.
-     *
-     *     def foo(...)
-     *       bar(...)
-     *           ^^^
-     *     end
-     *
- */ - public static final class ForwardingArgumentsNode extends Node { - - public ForwardingArgumentsNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitForwardingArgumentsNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the forwarding parameter in a method, block, or lambda declaration.
-     *
-     *     def foo(...)
-     *             ^^^
-     *     end
-     *
- */ - public static final class ForwardingParameterNode extends Node { - - public ForwardingParameterNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitForwardingParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `super` keyword without parentheses or arguments.
-     *
-     *     super
-     *     ^^^^^
-     *
- */ - public static final class ForwardingSuperNode extends Node { - @Nullable - public final BlockNode block; - - public ForwardingSuperNode(int startOffset, int length, BlockNode block) { - super(startOffset, length); - this.block = block; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.block != null) { - this.block.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.block }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitForwardingSuperNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator for assignment to a global variable.
-     *
-     *     $target &&= value
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class GlobalVariableAndWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - - public GlobalVariableAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitGlobalVariableAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to a global variable using an operator that isn't `=`.
-     *
-     *     $target += value
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class GlobalVariableOperatorWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - public final org.jruby.RubySymbol binary_operator; - - public GlobalVariableOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { - super(startOffset, length); - this.name = name; - this.value = value; - this.binary_operator = binary_operator; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitGlobalVariableOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator for assignment to a global variable.
-     *
-     *     $target ||= value
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class GlobalVariableOrWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - - public GlobalVariableOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitGlobalVariableOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents referencing a global variable.
-     *
-     *     $foo
-     *     ^^^^
-     *
- */ - public static final class GlobalVariableReadNode extends Node { - /** - * 
-         * The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
-         *
-         *     $foo   # name `:$foo`
-         *
-         *     $_Test # name `:$_Test`
-         *
- */ - public final org.jruby.RubySymbol name; - - public GlobalVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitGlobalVariableReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a global variable in a context that doesn't have an explicit value.
-     *
-     *     $foo, $bar = baz
-     *     ^^^^  ^^^^
-     *
- */ - public static final class GlobalVariableTargetNode extends Node { - public final org.jruby.RubySymbol name; - - public GlobalVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitGlobalVariableTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a global variable.
-     *
-     *     $foo = 1
-     *     ^^^^^^^^
-     *
- */ - public static final class GlobalVariableWriteNode extends Node { - /** - * 
-         * The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
-         *
-         *     $foo = :bar  # name `:$foo`
-         *
-         *     $_Test = 123 # name `:$_Test`
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     $foo = :bar
-         *            ^^^^
-         *
-         *     $-xyz = 123
-         *             ^^^
-         *
- */ - public final Node value; - - public GlobalVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitGlobalVariableWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a hash literal.
-     *
-     *     { a => b }
-     *     ^^^^^^^^^^
-     *
- */ - public static final class HashNode extends Node { - /** - * 
-         * The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
-         *
-         *     { a: b }
-         *       ^^^^
-         *
-         *     { **foo }
-         *       ^^^^^
-         *
- */ - @UnionType({ AssocNode.class, AssocSplatNode.class }) - public final Node[] elements; - - public HashNode(int startOffset, int length, Node[] elements) { - super(startOffset, length); - this.elements = elements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.elements) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.elements)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitHashNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("elements: "); - builder.append('\n'); - for (Node child : this.elements) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a hash pattern in pattern matching.
-     *
-     *     foo => { a: 1, b: 2 }
-     *            ^^^^^^^^^^^^^^
-     *
-     *     foo => { a: 1, b: 2, **c }
-     *            ^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class HashPatternNode extends Node { - @Nullable - @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) - public final Node constant; - public final AssocNode[] elements; - @Nullable - @UnionType({ AssocSplatNode.class, NoKeywordsParameterNode.class }) - public final Node rest; - - public HashPatternNode(int startOffset, int length, Node constant, AssocNode[] elements, Node rest) { - super(startOffset, length); - this.constant = constant; - this.elements = elements; - this.rest = rest; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.constant != null) { - this.constant.accept(visitor); - } - for (Nodes.Node child : this.elements) { - child.accept(visitor); - } - if (this.rest != null) { - this.rest.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.add(this.constant); - childNodes.addAll(Arrays.asList(this.elements)); - childNodes.add(this.rest); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitHashPatternNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("constant: "); - builder.append(this.constant == null ? "null\n" : this.constant.toString(nextIndent)); - builder.append(nextIndent); - builder.append("elements: "); - builder.append('\n'); - for (Node child : this.elements) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("rest: "); - builder.append(this.rest == null ? "null\n" : this.rest.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
-     *
-     *     bar if foo
-     *     ^^^^^^^^^^
-     *
-     *     if foo then bar end
-     *     ^^^^^^^^^^^^^^^^^^^
-     *
-     *     foo ? bar : baz
-     *     ^^^^^^^^^^^^^^^
-     *
- */ - public static final class IfNode extends Node { - /** - * 
-         * The node for the condition the `IfNode` is testing.
-         *
-         *     if foo
-         *        ^^^
-         *       bar
-         *     end
-         *
-         *     bar if foo
-         *            ^^^
-         *
-         *     foo ? bar : baz
-         *     ^^^
-         *
- */ - public final Node predicate; - /** - * 
-         * Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
-         *
-         *     if foo
-         *       bar
-         *       ^^^
-         *       baz
-         *       ^^^
-         *     end
-         *
- */ - @Nullable - public final StatementsNode statements; - /** - * 
-         * Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
-         *
-         *     if foo
-         *       bar
-         *     elsif baz
-         *     ^^^^^^^^^
-         *       qux
-         *       ^^^
-         *     end
-         *     ^^^
-         *
-         *     if foo then bar else baz end
-         *                     ^^^^^^^^^^^^
-         *
- */ - @Nullable - @UnionType({ ElseNode.class, IfNode.class }) - public final Node subsequent; - - public IfNode(int startOffset, int length, Node predicate, StatementsNode statements, Node subsequent) { - super(startOffset, length); - this.predicate = predicate; - this.statements = statements; - this.subsequent = subsequent; - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - this.predicate.setNewLineFlag(source, newlineMarked); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.predicate.accept(visitor); - if (this.statements != null) { - this.statements.accept(visitor); - } - if (this.subsequent != null) { - this.subsequent.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.predicate, this.statements, this.subsequent }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitIfNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("predicate: "); - builder.append(this.predicate.toString(nextIndent)); - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - builder.append(nextIndent); - builder.append("subsequent: "); - builder.append(this.subsequent == null ? "null\n" : this.subsequent.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an imaginary number literal.
-     *
-     *     1.0i
-     *     ^^^^
-     *
- */ - public static final class ImaginaryNode extends Node { - @UnionType({ FloatNode.class, IntegerNode.class, RationalNode.class }) - public final Node numeric; - - public ImaginaryNode(int startOffset, int length, Node numeric) { - super(startOffset, length); - this.numeric = numeric; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.numeric.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.numeric }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitImaginaryNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("numeric: "); - builder.append(this.numeric.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
-     *
-     *     { foo: }
-     *       ^^^^
-     *
-     *     { Foo: }
-     *       ^^^^
-     *
-     *     foo in { bar: }
-     *              ^^^^
-     *
- */ - public static final class ImplicitNode extends Node { - @UnionType({ LocalVariableReadNode.class, CallNode.class, ConstantReadNode.class, LocalVariableTargetNode.class }) - public final Node value; - - public ImplicitNode(int startOffset, int length, Node value) { - super(startOffset, length); - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitImplicitNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents using a trailing comma to indicate an implicit rest parameter.
-     *
-     *     foo { |bar,| }
-     *               ^
-     *
-     *     foo in [bar,]
-     *                ^
-     *
-     *     for foo, in bar do end
-     *            ^
-     *
-     *     foo, = bar
-     *        ^
-     *
- */ - public static final class ImplicitRestNode extends Node { - - public ImplicitRestNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitImplicitRestNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `in` keyword in a case statement.
-     *
-     *     case a; in b then c end
-     *             ^^^^^^^^^^^
-     *
- */ - public static final class InNode extends Node { - public final Node pattern; - @Nullable - public final StatementsNode statements; - - public InNode(int startOffset, int length, Node pattern, StatementsNode statements) { - super(startOffset, length); - this.pattern = pattern; - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.pattern.accept(visitor); - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.pattern, this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("pattern: "); - builder.append(this.pattern.toString(nextIndent)); - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator on a call to the `[]` method.
-     *
-     *     foo.bar[baz] &&= value
-     *     ^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class IndexAndWriteNode extends Node { - public final short flags; - @Nullable - public final Node receiver; - @Nullable - public final ArgumentsNode arguments; - @Nullable - public final BlockArgumentNode block; - public final Node value; - - public IndexAndWriteNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block, Node value) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.arguments = arguments; - this.block = block; - this.value = value; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - if (this.arguments != null) { - this.arguments.accept(visitor); - } - if (this.block != null) { - this.block.accept(visitor); - } - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.arguments, this.block, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitIndexAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of an assignment operator on a call to `[]`.
-     *
-     *     foo.bar[baz] += value
-     *     ^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class IndexOperatorWriteNode extends Node { - public final short flags; - @Nullable - public final Node receiver; - @Nullable - public final ArgumentsNode arguments; - @Nullable - public final BlockArgumentNode block; - public final org.jruby.RubySymbol binary_operator; - public final Node value; - - public IndexOperatorWriteNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block, org.jruby.RubySymbol binary_operator, Node value) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.arguments = arguments; - this.block = block; - this.binary_operator = binary_operator; - this.value = value; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - if (this.arguments != null) { - this.arguments.accept(visitor); - } - if (this.block != null) { - this.block.accept(visitor); - } - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.arguments, this.block, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitIndexOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator on a call to `[]`.
-     *
-     *     foo.bar[baz] ||= value
-     *     ^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class IndexOrWriteNode extends Node { - public final short flags; - @Nullable - public final Node receiver; - @Nullable - public final ArgumentsNode arguments; - @Nullable - public final BlockArgumentNode block; - public final Node value; - - public IndexOrWriteNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block, Node value) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.arguments = arguments; - this.block = block; - this.value = value; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.receiver != null) { - this.receiver.accept(visitor); - } - if (this.arguments != null) { - this.arguments.accept(visitor); - } - if (this.block != null) { - this.block.accept(visitor); - } - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.arguments, this.block, this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitIndexOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver == null ? "null\n" : this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to an index.
-     *
-     *     foo[bar], = 1
-     *     ^^^^^^^^
-     *
-     *     begin
-     *     rescue => foo[bar]
-     *               ^^^^^^^^
-     *     end
-     *
-     *     for foo[bar] in baz do end
-     *         ^^^^^^^^
-     *
- */ - public static final class IndexTargetNode extends Node { - public final short flags; - public final Node receiver; - @Nullable - public final ArgumentsNode arguments; - @Nullable - public final BlockArgumentNode block; - - public IndexTargetNode(int startOffset, int length, short flags, Node receiver, ArgumentsNode arguments, BlockArgumentNode block) { - super(startOffset, length); - this.flags = flags; - this.receiver = receiver; - this.arguments = arguments; - this.block = block; - } - - public boolean isSafeNavigation() { - return CallNodeFlags.isSafeNavigation(flags); - } - - public boolean isVariableCall() { - return CallNodeFlags.isVariableCall(flags); - } - - public boolean isAttributeWrite() { - return CallNodeFlags.isAttributeWrite(flags); - } - - public boolean isIgnoreVisibility() { - return CallNodeFlags.isIgnoreVisibility(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.receiver.accept(visitor); - if (this.arguments != null) { - this.arguments.accept(visitor); - } - if (this.block != null) { - this.block.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.receiver, this.arguments, this.block }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitIndexTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("CallNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("receiver: "); - builder.append(this.receiver.toString(nextIndent)); - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator for assignment to an instance variable.
-     *
-     *     @target &&= value
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InstanceVariableAndWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - - public InstanceVariableAndWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInstanceVariableAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to an instance variable using an operator that isn't `=`.
-     *
-     *     @target += value
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InstanceVariableOperatorWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - public final org.jruby.RubySymbol binary_operator; - - public InstanceVariableOperatorWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value, org.jruby.RubySymbol binary_operator) { - super(startOffset, length); - this.name = name; - this.value = value; - this.binary_operator = binary_operator; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInstanceVariableOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator for assignment to an instance variable.
-     *
-     *     @target ||= value
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InstanceVariableOrWriteNode extends Node { - public final org.jruby.RubySymbol name; - public final Node value; - - public InstanceVariableOrWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInstanceVariableOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents referencing an instance variable.
-     *
-     *     @foo
-     *     ^^^^
-     *
- */ - public static final class InstanceVariableReadNode extends Node { - /** - * 
-         * The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-         *
-         *     @x     # name `:@x`
-         *
-         *     @_test # name `:@_test`
-         *
- */ - public final org.jruby.RubySymbol name; - - public InstanceVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInstanceVariableReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to an instance variable in a context that doesn't have an explicit value.
-     *
-     *     @foo, @bar = baz
-     *     ^^^^  ^^^^
-     *
- */ - public static final class InstanceVariableTargetNode extends Node { - public final org.jruby.RubySymbol name; - - public InstanceVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name) { - super(startOffset, length); - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInstanceVariableTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to an instance variable.
-     *
-     *     @foo = 1
-     *     ^^^^^^^^
-     *
- */ - public static final class InstanceVariableWriteNode extends Node { - /** - * 
-         * The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-         *
-         *     @x = :y       # name `:@x`
-         *
-         *     @_foo = "bar" # name `@_foo`
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     @foo = :bar
-         *            ^^^^
-         *
-         *     @_x = 1234
-         *           ^^^^
-         *
- */ - public final Node value; - - public InstanceVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.name = name; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInstanceVariableWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an integer number literal.
-     *
-     *     1
-     *     ^
-     *
- */ - public static final class IntegerNode extends Node { - public final short flags; - /** - * 
-         * The value of the integer literal as a number.
-         *
- */ - public final Object value; - - public IntegerNode(int startOffset, int length, short flags, Object value) { - super(startOffset, length); - this.flags = flags; - this.value = value; - } - - public boolean isBinary() { - return IntegerBaseFlags.isBinary(flags); - } - - public boolean isDecimal() { - return IntegerBaseFlags.isDecimal(flags); - } - - public boolean isOctal() { - return IntegerBaseFlags.isOctal(flags); - } - - public boolean isHexadecimal() { - return IntegerBaseFlags.isHexadecimal(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitIntegerNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("IntegerBaseFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
-     *
-     *     if /foo #{bar} baz/ then end
-     *        ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InterpolatedMatchLastLineNode extends Node { - public final short flags; - @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) - public final Node[] parts; - - public InterpolatedMatchLastLineNode(int startOffset, int length, short flags, Node[] parts) { - super(startOffset, length); - this.flags = flags; - this.parts = parts; - } - - public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(flags); - } - - public boolean isExtended() { - return RegularExpressionFlags.isExtended(flags); - } - - public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(flags); - } - - public boolean isOnce() { - return RegularExpressionFlags.isOnce(flags); - } - - public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(flags); - } - - public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(flags); - } - - public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(flags); - } - - public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(flags); - } - - public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(flags); - } - - public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - Node first = this.parts.length > 0 ? this.parts[0] : null; - if (first != null) { - first.setNewLineFlag(source, newlineMarked); - } - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.parts) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.parts)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInterpolatedMatchLastLineNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("RegularExpressionFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("parts: "); - builder.append('\n'); - for (Node child : this.parts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a regular expression literal that contains interpolation.
-     *
-     *     /foo #{bar} baz/
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InterpolatedRegularExpressionNode extends Node { - public final short flags; - @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) - public final Node[] parts; - - public InterpolatedRegularExpressionNode(int startOffset, int length, short flags, Node[] parts) { - super(startOffset, length); - this.flags = flags; - this.parts = parts; - } - - public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(flags); - } - - public boolean isExtended() { - return RegularExpressionFlags.isExtended(flags); - } - - public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(flags); - } - - public boolean isOnce() { - return RegularExpressionFlags.isOnce(flags); - } - - public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(flags); - } - - public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(flags); - } - - public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(flags); - } - - public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(flags); - } - - public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(flags); - } - - public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - Node first = this.parts.length > 0 ? this.parts[0] : null; - if (first != null) { - first.setNewLineFlag(source, newlineMarked); - } - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.parts) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.parts)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInterpolatedRegularExpressionNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("RegularExpressionFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("parts: "); - builder.append('\n'); - for (Node child : this.parts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a string literal that contains interpolation.
-     *
-     *     "foo #{bar} baz"
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InterpolatedStringNode extends Node { - public final short flags; - @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class, InterpolatedStringNode.class }) - public final Node[] parts; - - public InterpolatedStringNode(int startOffset, int length, short flags, Node[] parts) { - super(startOffset, length); - this.flags = flags; - this.parts = parts; - } - - public boolean isFrozen() { - return InterpolatedStringNodeFlags.isFrozen(flags); - } - - public boolean isMutable() { - return InterpolatedStringNodeFlags.isMutable(flags); - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - Node first = this.parts.length > 0 ? this.parts[0] : null; - if (first != null) { - first.setNewLineFlag(source, newlineMarked); - } - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.parts) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.parts)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInterpolatedStringNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("InterpolatedStringNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("parts: "); - builder.append('\n'); - for (Node child : this.parts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a symbol literal that contains interpolation.
-     *
-     *     :"foo #{bar} baz"
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InterpolatedSymbolNode extends Node { - @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) - public final Node[] parts; - - public InterpolatedSymbolNode(int startOffset, int length, Node[] parts) { - super(startOffset, length); - this.parts = parts; - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - Node first = this.parts.length > 0 ? this.parts[0] : null; - if (first != null) { - first.setNewLineFlag(source, newlineMarked); - } - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.parts) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.parts)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInterpolatedSymbolNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("parts: "); - builder.append('\n'); - for (Node child : this.parts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents an xstring literal that contains interpolation.
-     *
-     *     `foo #{bar} baz`
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class InterpolatedXStringNode extends Node { - @UnionType({ StringNode.class, EmbeddedStatementsNode.class, EmbeddedVariableNode.class }) - public final Node[] parts; - - public InterpolatedXStringNode(int startOffset, int length, Node[] parts) { - super(startOffset, length); - this.parts = parts; - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - Node first = this.parts.length > 0 ? this.parts[0] : null; - if (first != null) { - first.setNewLineFlag(source, newlineMarked); - } - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.parts) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.parts)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitInterpolatedXStringNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("parts: "); - builder.append('\n'); - for (Node child : this.parts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents reading from the implicit `it` local variable.
-     *
-     *     -> { it }
-     *          ^^
-     *
- */ - public static final class ItLocalVariableReadNode extends Node { - - public ItLocalVariableReadNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitItLocalVariableReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
-     *
-     *     -> { it + it }
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class ItParametersNode extends Node { - - public ItParametersNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitItParametersNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents a hash literal without opening and closing braces.
-     *
-     *     foo(a: b)
-     *         ^^^^
-     *
- */ - public static final class KeywordHashNode extends Node { - public final short flags; - @UnionType({ AssocNode.class, AssocSplatNode.class }) - public final Node[] elements; - - public KeywordHashNode(int startOffset, int length, short flags, Node[] elements) { - super(startOffset, length); - this.flags = flags; - this.elements = elements; - } - - public boolean isSymbolKeys() { - return KeywordHashNodeFlags.isSymbolKeys(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.elements) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.elements)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitKeywordHashNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("KeywordHashNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("elements: "); - builder.append('\n'); - for (Node child : this.elements) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a keyword rest parameter to a method, block, or lambda definition.
-     *
-     *     def a(**b)
-     *           ^^^
-     *     end
-     *
- */ - public static final class KeywordRestParameterNode extends Node { - public final short flags; - @Nullable - public final org.jruby.RubySymbol name; - - public KeywordRestParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { - super(startOffset, length); - this.flags = flags; - this.name = name; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitKeywordRestParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append(this.name == null ? "null" : "\"" + this.name + "\""); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents using a lambda literal (not the lambda method call).
-     *
-     *     ->(value) { value * 2 }
-     *     ^^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class LambdaNode extends Node { - public final org.jruby.RubySymbol[] locals; - @Nullable - @UnionType({ BlockParametersNode.class, NumberedParametersNode.class, ItParametersNode.class }) - public final Node parameters; - @Nullable - @UnionType({ StatementsNode.class, BeginNode.class }) - public final Node body; - - public LambdaNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node parameters, Node body) { - super(startOffset, length); - this.locals = locals; - this.parameters = parameters; - this.body = body; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.parameters != null) { - this.parameters.accept(visitor); - } - if (this.body != null) { - this.body.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.parameters, this.body }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitLambdaNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (org.jruby.RubySymbol constant : this.locals) { - builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n'); - } - builder.append(nextIndent); - builder.append("parameters: "); - builder.append(this.parameters == null ? "null\n" : this.parameters.toString(nextIndent)); - builder.append(nextIndent); - builder.append("body: "); - builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `&&=` operator for assignment to a local variable.
-     *
-     *     target &&= value
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class LocalVariableAndWriteNode extends Node { - public final Node value; - public final org.jruby.RubySymbol name; - public final int depth; - - public LocalVariableAndWriteNode(int startOffset, int length, Node value, org.jruby.RubySymbol name, int depth) { - super(startOffset, length); - this.value = value; - this.name = name; - this.depth = depth; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitLocalVariableAndWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("depth: "); - builder.append(this.depth); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents assigning to a local variable using an operator that isn't `=`.
-     *
-     *     target += value
-     *     ^^^^^^^^^^^^^^^
-     *
- */ - public static final class LocalVariableOperatorWriteNode extends Node { - public final Node value; - public final org.jruby.RubySymbol name; - public final org.jruby.RubySymbol binary_operator; - public final int depth; - - public LocalVariableOperatorWriteNode(int startOffset, int length, Node value, org.jruby.RubySymbol name, org.jruby.RubySymbol binary_operator, int depth) { - super(startOffset, length); - this.value = value; - this.name = name; - this.binary_operator = binary_operator; - this.depth = depth; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitLocalVariableOperatorWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("binary_operator: "); - builder.append('"').append(this.binary_operator).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("depth: "); - builder.append(this.depth); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||=` operator for assignment to a local variable.
-     *
-     *     target ||= value
-     *     ^^^^^^^^^^^^^^^^
-     *
- */ - public static final class LocalVariableOrWriteNode extends Node { - public final Node value; - public final org.jruby.RubySymbol name; - public final int depth; - - public LocalVariableOrWriteNode(int startOffset, int length, Node value, org.jruby.RubySymbol name, int depth) { - super(startOffset, length); - this.value = value; - this.name = name; - this.depth = depth; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitLocalVariableOrWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("depth: "); - builder.append(this.depth); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
-     *
-     *     foo
-     *     ^^^
-     *
- */ - public static final class LocalVariableReadNode extends Node { - /** - * 
-         * The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-         *
-         *     x      # name `:x`
-         *
-         *     _Test  # name `:_Test`
-         *
-         * Note that this can also be an underscore followed by a number for the default block parameters.
-         *
-         *     _1     # name `:_1`
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * The number of visible scopes that should be searched to find the origin of this local variable.
-         *
-         *     foo = 1; foo # depth 0
-         *
-         *     bar = 2; tap { bar } # depth 1
-         *
-         * The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
-         *
- */ - public final int depth; - - public LocalVariableReadNode(int startOffset, int length, org.jruby.RubySymbol name, int depth) { - super(startOffset, length); - this.name = name; - this.depth = depth; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitLocalVariableReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("depth: "); - builder.append(this.depth); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a local variable in a context that doesn't have an explicit value.
-     *
-     *     foo, bar = baz
-     *     ^^^  ^^^
-     *
- */ - public static final class LocalVariableTargetNode extends Node { - public final org.jruby.RubySymbol name; - public final int depth; - - public LocalVariableTargetNode(int startOffset, int length, org.jruby.RubySymbol name, int depth) { - super(startOffset, length); - this.name = name; - this.depth = depth; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitLocalVariableTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("depth: "); - builder.append(this.depth); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing to a local variable.
-     *
-     *     foo = 1
-     *     ^^^^^^^
-     *
- */ - public static final class LocalVariableWriteNode extends Node { - /** - * 
-         * The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-         *
-         *     foo = :bar # name `:foo`
-         *
-         *     abc = 123  # name `:abc`
-         *
- */ - public final org.jruby.RubySymbol name; - /** - * 
-         * The number of semantic scopes we have to traverse to find the declaration of this variable.
-         *
-         *     foo = 1         # depth 0
-         *
-         *     tap { foo = 1 } # depth 1
-         *
-         * The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
-         *
- */ - public final int depth; - /** - * 
-         * The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     foo = :bar
-         *           ^^^^
-         *
-         *     abc = 1234
-         *           ^^^^
-         *
-         * Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
-         *
-         *     foo = foo
-         *
- */ - public final Node value; - - public LocalVariableWriteNode(int startOffset, int length, org.jruby.RubySymbol name, int depth, Node value) { - super(startOffset, length); - this.name = name; - this.depth = depth; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitLocalVariableWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("depth: "); - builder.append(this.depth); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
-     *
-     *     if /foo/i then end
-     *        ^^^^^^
-     *
- */ - public static final class MatchLastLineNode extends Node { - public final short flags; - public final byte[] unescaped; - - public MatchLastLineNode(int startOffset, int length, short flags, byte[] unescaped) { - super(startOffset, length); - this.flags = flags; - this.unescaped = unescaped; - } - - public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(flags); - } - - public boolean isExtended() { - return RegularExpressionFlags.isExtended(flags); - } - - public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(flags); - } - - public boolean isOnce() { - return RegularExpressionFlags.isOnce(flags); - } - - public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(flags); - } - - public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(flags); - } - - public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(flags); - } - - public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(flags); - } - - public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(flags); - } - - public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitMatchLastLineNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("RegularExpressionFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("unescaped: "); - builder.append('"' + new String(this.unescaped, StandardCharsets.UTF_8) + '"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the modifier `in` operator.
-     *
-     *     foo in bar
-     *     ^^^^^^^^^^
-     *
- */ - public static final class MatchPredicateNode extends Node { - public final Node value; - public final Node pattern; - - public MatchPredicateNode(int startOffset, int length, Node value, Node pattern) { - super(startOffset, length); - this.value = value; - this.pattern = pattern; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - this.pattern.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value, this.pattern }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitMatchPredicateNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("pattern: "); - builder.append(this.pattern.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `=>` operator.
-     *
-     *     foo => bar
-     *     ^^^^^^^^^^
-     *
- */ - public static final class MatchRequiredNode extends Node { - public final Node value; - public final Node pattern; - - public MatchRequiredNode(int startOffset, int length, Node value, Node pattern) { - super(startOffset, length); - this.value = value; - this.pattern = pattern; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - this.pattern.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value, this.pattern }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitMatchRequiredNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - builder.append(nextIndent); - builder.append("pattern: "); - builder.append(this.pattern.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents writing local variables using a regular expression match with named capture groups.
-     *
-     *     /(?<foo>bar)/ =~ baz
-     *     ^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class MatchWriteNode extends Node { - public final CallNode call; - public final LocalVariableTargetNode[] targets; - - public MatchWriteNode(int startOffset, int length, CallNode call, LocalVariableTargetNode[] targets) { - super(startOffset, length); - this.call = call; - this.targets = targets; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.call.accept(visitor); - for (Nodes.Node child : this.targets) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.add(this.call); - childNodes.addAll(Arrays.asList(this.targets)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitMatchWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("call: "); - builder.append(this.call.toString(nextIndent)); - builder.append(nextIndent); - builder.append("targets: "); - builder.append('\n'); - for (Node child : this.targets) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a node that is missing from the source and results in a syntax error.
-     *
- */ - public static final class MissingNode extends Node { - - public MissingNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitMissingNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents a module declaration involving the `module` keyword.
-     *
-     *     module Foo end
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class ModuleNode extends Node { - public final org.jruby.RubySymbol[] locals; - @UnionType({ ConstantReadNode.class, ConstantPathNode.class }) - public final Node constant_path; - @Nullable - @UnionType({ StatementsNode.class, BeginNode.class }) - public final Node body; - public final org.jruby.RubySymbol name; - - public ModuleNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node constant_path, Node body, org.jruby.RubySymbol name) { - super(startOffset, length); - this.locals = locals; - this.constant_path = constant_path; - this.body = body; - this.name = name; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.constant_path.accept(visitor); - if (this.body != null) { - this.body.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.constant_path, this.body }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitModuleNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (org.jruby.RubySymbol constant : this.locals) { - builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n'); - } - builder.append(nextIndent); - builder.append("constant_path: "); - builder.append(this.constant_path.toString(nextIndent)); - builder.append(nextIndent); - builder.append("body: "); - builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents a multi-target expression.
-     *
-     *     a, (b, c) = 1, 2, 3
-     *        ^^^^^^
-     *
-     * This can be a part of `MultiWriteNode` as above, or the target of a `for` loop
-     *
-     *     for a, b in [[1, 2], [3, 4]]
-     *         ^^^^
-     *
- */ - public static final class MultiTargetNode extends Node { - /** - * 
-         * Represents the targets expressions before a splat node.
-         *
-         *     a, (b, c, *) = 1, 2, 3, 4, 5
-         *         ^^^^
-         *
-         * The splat node can be absent, in that case all target expressions are in the left field.
-         *
-         *     a, (b, c) = 1, 2, 3, 4, 5
-         *         ^^^^
-         *
- */ - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class, RequiredParameterNode.class }) - public final Node[] lefts; - /** - * 
-         * Represents a splat node in the target expression.
-         *
-         *     a, (b, *c) = 1, 2, 3, 4
-         *            ^^
-         *
-         * The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
-         *
-         *     a, (b, *) = 1, 2, 3, 4
-         *            ^
-         *
-         * If the `*` is omitted, this field will contain an `ImplicitRestNode`
-         *
-         *     a, (b,) = 1, 2, 3, 4
-         *          ^
-         *
- */ - @Nullable - @UnionType({ ImplicitRestNode.class, SplatNode.class }) - public final Node rest; - /** - * 
-         * Represents the targets expressions after a splat node.
-         *
-         *     a, (*, b, c) = 1, 2, 3, 4, 5
-         *            ^^^^
-         *
- */ - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class, RequiredParameterNode.class }) - public final Node[] rights; - - public MultiTargetNode(int startOffset, int length, Node[] lefts, Node rest, Node[] rights) { - super(startOffset, length); - this.lefts = lefts; - this.rest = rest; - this.rights = rights; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.lefts) { - child.accept(visitor); - } - if (this.rest != null) { - this.rest.accept(visitor); - } - for (Nodes.Node child : this.rights) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.lefts)); - childNodes.add(this.rest); - childNodes.addAll(Arrays.asList(this.rights)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitMultiTargetNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("lefts: "); - builder.append('\n'); - for (Node child : this.lefts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("rest: "); - builder.append(this.rest == null ? "null\n" : this.rest.toString(nextIndent)); - builder.append(nextIndent); - builder.append("rights: "); - builder.append('\n'); - for (Node child : this.rights) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a write to a multi-target expression.
-     *
-     *     a, b, c = 1, 2, 3
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class MultiWriteNode extends Node { - /** - * 
-         * Represents the targets expressions before a splat node.
-         *
-         *     a, b, * = 1, 2, 3, 4, 5
-         *     ^^^^
-         *
-         * The splat node can be absent, in that case all target expressions are in the left field.
-         *
-         *     a, b, c = 1, 2, 3, 4, 5
-         *     ^^^^^^^
-         *
- */ - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class }) - public final Node[] lefts; - /** - * 
-         * Represents a splat node in the target expression.
-         *
-         *     a, b, *c = 1, 2, 3, 4
-         *           ^^
-         *
-         * The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
-         *
-         *     a, b, * = 1, 2, 3, 4
-         *           ^
-         *
-         * If the `*` is omitted, this field will contain an `ImplicitRestNode`
-         *
-         *     a, b, = 1, 2, 3, 4
-         *         ^
-         *
- */ - @Nullable - @UnionType({ ImplicitRestNode.class, SplatNode.class }) - public final Node rest; - /** - * 
-         * Represents the targets expressions after a splat node.
-         *
-         *     a, *, b, c = 1, 2, 3, 4, 5
-         *           ^^^^
-         *
- */ - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class, MultiTargetNode.class }) - public final Node[] rights; - /** - * 
-         * The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     a, b, c = 1, 2, 3
-         *               ^^^^^^^
-         *
- */ - public final Node value; - - public MultiWriteNode(int startOffset, int length, Node[] lefts, Node rest, Node[] rights, Node value) { - super(startOffset, length); - this.lefts = lefts; - this.rest = rest; - this.rights = rights; - this.value = value; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.lefts) { - child.accept(visitor); - } - if (this.rest != null) { - this.rest.accept(visitor); - } - for (Nodes.Node child : this.rights) { - child.accept(visitor); - } - this.value.accept(visitor); - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.lefts)); - childNodes.add(this.rest); - childNodes.addAll(Arrays.asList(this.rights)); - childNodes.add(this.value); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitMultiWriteNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("lefts: "); - builder.append('\n'); - for (Node child : this.lefts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("rest: "); - builder.append(this.rest == null ? "null\n" : this.rest.toString(nextIndent)); - builder.append(nextIndent); - builder.append("rights: "); - builder.append('\n'); - for (Node child : this.rights) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `next` keyword.
-     *
-     *     next 1
-     *     ^^^^^^
-     *
- */ - public static final class NextNode extends Node { - @Nullable - public final ArgumentsNode arguments; - - public NextNode(int startOffset, int length, ArgumentsNode arguments) { - super(startOffset, length); - this.arguments = arguments; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.arguments != null) { - this.arguments.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.arguments }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitNextNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `nil` keyword.
-     *
-     *     nil
-     *     ^^^
-     *
- */ - public static final class NilNode extends Node { - - public NilNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitNilNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of `**nil` inside method arguments.
-     *
-     *     def a(**nil)
-     *           ^^^^^
-     *     end
-     *
- */ - public static final class NoKeywordsParameterNode extends Node { - - public NoKeywordsParameterNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitNoKeywordsParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
-     *
-     *     -> { _1 + _2 }
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class NumberedParametersNode extends Node { - public final int maximum; - - public NumberedParametersNode(int startOffset, int length, int maximum) { - super(startOffset, length); - this.maximum = maximum; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitNumberedParametersNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("maximum: "); - builder.append(this.maximum); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents reading a numbered reference to a capture in the previous match.
-     *
-     *     $1
-     *     ^^
-     *
- */ - public static final class NumberedReferenceReadNode extends Node { - /** - * 
-         * The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
-         *
-         *     $1          # number `1`
-         *
-         *     $5432       # number `5432`
-         *
-         *     $4294967296 # number `0`
-         *
- */ - public final int number; - - public NumberedReferenceReadNode(int startOffset, int length, int number) { - super(startOffset, length); - this.number = number; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitNumberedReferenceReadNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("number: "); - builder.append(this.number); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents an optional keyword parameter to a method, block, or lambda definition.
-     *
-     *     def a(b: 1)
-     *           ^^^^
-     *     end
-     *
- */ - public static final class OptionalKeywordParameterNode extends Node { - public final short flags; - public final org.jruby.RubySymbol name; - public final Node value; - - public OptionalKeywordParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.flags = flags; - this.name = name; - this.value = value; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitOptionalKeywordParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an optional parameter to a method, block, or lambda definition.
-     *
-     *     def a(b = 1)
-     *           ^^^^^
-     *     end
-     *
- */ - public static final class OptionalParameterNode extends Node { - public final short flags; - public final org.jruby.RubySymbol name; - public final Node value; - - public OptionalParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name, Node value) { - super(startOffset, length); - this.flags = flags; - this.name = name; - this.value = value; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.value.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.value }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitOptionalParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - builder.append(nextIndent); - builder.append("value: "); - builder.append(this.value.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `||` operator or the `or` keyword.
-     *
-     *     left or right
-     *     ^^^^^^^^^^^^^
-     *
- */ - public static final class OrNode extends Node { - /** - * 
-         * Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     left or right
-         *     ^^^^
-         *
-         *     1 || 2
-         *     ^
-         *
- */ - public final Node left; - /** - * 
-         * Represents the right side of the expression.
-         *
-         *     left || right
-         *             ^^^^^
-         *
-         *     1 or 2
-         *          ^
-         *
- */ - public final Node right; - - public OrNode(int startOffset, int length, Node left, Node right) { - super(startOffset, length); - this.left = left; - this.right = right; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.left.accept(visitor); - this.right.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.left, this.right }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitOrNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("left: "); - builder.append(this.left.toString(nextIndent)); - builder.append(nextIndent); - builder.append("right: "); - builder.append(this.right.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the list of parameters on a method, block, or lambda definition.
-     *
-     *     def a(b, c, d)
-     *           ^^^^^^^
-     *     end
-     *
- */ - public static final class ParametersNode extends Node { - @UnionType({ RequiredParameterNode.class, MultiTargetNode.class }) - public final Node[] requireds; - public final OptionalParameterNode[] optionals; - @Nullable - @UnionType({ RestParameterNode.class, ImplicitRestNode.class }) - public final Node rest; - @UnionType({ RequiredParameterNode.class, MultiTargetNode.class }) - public final Node[] posts; - @UnionType({ RequiredKeywordParameterNode.class, OptionalKeywordParameterNode.class }) - public final Node[] keywords; - @Nullable - @UnionType({ KeywordRestParameterNode.class, ForwardingParameterNode.class, NoKeywordsParameterNode.class }) - public final Node keyword_rest; - @Nullable - public final BlockParameterNode block; - - public ParametersNode(int startOffset, int length, Node[] requireds, OptionalParameterNode[] optionals, Node rest, Node[] posts, Node[] keywords, Node keyword_rest, BlockParameterNode block) { - super(startOffset, length); - this.requireds = requireds; - this.optionals = optionals; - this.rest = rest; - this.posts = posts; - this.keywords = keywords; - this.keyword_rest = keyword_rest; - this.block = block; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.requireds) { - child.accept(visitor); - } - for (Nodes.Node child : this.optionals) { - child.accept(visitor); - } - if (this.rest != null) { - this.rest.accept(visitor); - } - for (Nodes.Node child : this.posts) { - child.accept(visitor); - } - for (Nodes.Node child : this.keywords) { - child.accept(visitor); - } - if (this.keyword_rest != null) { - this.keyword_rest.accept(visitor); - } - if (this.block != null) { - this.block.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.requireds)); - childNodes.addAll(Arrays.asList(this.optionals)); - childNodes.add(this.rest); - childNodes.addAll(Arrays.asList(this.posts)); - childNodes.addAll(Arrays.asList(this.keywords)); - childNodes.add(this.keyword_rest); - childNodes.add(this.block); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitParametersNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("requireds: "); - builder.append('\n'); - for (Node child : this.requireds) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("optionals: "); - builder.append('\n'); - for (Node child : this.optionals) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("rest: "); - builder.append(this.rest == null ? "null\n" : this.rest.toString(nextIndent)); - builder.append(nextIndent); - builder.append("posts: "); - builder.append('\n'); - for (Node child : this.posts) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("keywords: "); - builder.append('\n'); - for (Node child : this.keywords) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("keyword_rest: "); - builder.append(this.keyword_rest == null ? "null\n" : this.keyword_rest.toString(nextIndent)); - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a parenthesized expression
-     *
-     *     (10 + 34)
-     *     ^^^^^^^^^
-     *
- */ - public static final class ParenthesesNode extends Node { - public final short flags; - @Nullable - public final Node body; - - public ParenthesesNode(int startOffset, int length, short flags, Node body) { - super(startOffset, length); - this.flags = flags; - this.body = body; - } - - public boolean isMultipleStatements() { - return ParenthesesNodeFlags.isMultipleStatements(flags); - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - // Never mark ParenthesesNode with a newline flag, mark children instead - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.body != null) { - this.body.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.body }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitParenthesesNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParenthesesNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("body: "); - builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
-     *
-     *     foo in ^(bar)
-     *            ^^^^^^
-     *
- */ - public static final class PinnedExpressionNode extends Node { - public final Node expression; - - public PinnedExpressionNode(int startOffset, int length, Node expression) { - super(startOffset, length); - this.expression = expression; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.expression.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.expression }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitPinnedExpressionNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("expression: "); - builder.append(this.expression.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
-     *
-     *     foo in ^bar
-     *            ^^^^
-     *
- */ - public static final class PinnedVariableNode extends Node { - @UnionType({ LocalVariableReadNode.class, InstanceVariableReadNode.class, ClassVariableReadNode.class, GlobalVariableReadNode.class, BackReferenceReadNode.class, NumberedReferenceReadNode.class, ItLocalVariableReadNode.class }) - public final Node variable; - - public PinnedVariableNode(int startOffset, int length, Node variable) { - super(startOffset, length); - this.variable = variable; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.variable.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.variable }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitPinnedVariableNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("variable: "); - builder.append(this.variable.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `END` keyword.
-     *
-     *     END { foo }
-     *     ^^^^^^^^^^^
-     *
- */ - public static final class PostExecutionNode extends Node { - @Nullable - public final StatementsNode statements; - - public PostExecutionNode(int startOffset, int length, StatementsNode statements) { - super(startOffset, length); - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitPostExecutionNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `BEGIN` keyword.
-     *
-     *     BEGIN { foo }
-     *     ^^^^^^^^^^^^^
-     *
- */ - public static final class PreExecutionNode extends Node { - @Nullable - public final StatementsNode statements; - - public PreExecutionNode(int startOffset, int length, StatementsNode statements) { - super(startOffset, length); - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitPreExecutionNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * The top level node of any parse tree.
-     *
- */ - public static final class ProgramNode extends Node { - public final org.jruby.RubySymbol[] locals; - public final StatementsNode statements; - - public ProgramNode(int startOffset, int length, org.jruby.RubySymbol[] locals, StatementsNode statements) { - super(startOffset, length); - this.locals = locals; - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.statements.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitProgramNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (org.jruby.RubySymbol constant : this.locals) { - builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n'); - } - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `..` or `...` operators.
-     *
-     *     1..2
-     *     ^^^^
-     *
-     *     c if a =~ /left/ ... b =~ /right/
-     *          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class RangeNode extends Node { - public final short flags; - /** - * 
-         * The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     1...
-         *     ^
-         *
-         *     hello...goodbye
-         *     ^^^^^
-         *
- */ - @Nullable - public final Node left; - /** - * 
-         * The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     ..5
-         *       ^
-         *
-         *     1...foo
-         *         ^^^
-         * If neither right-hand or left-hand side was included, this will be a MissingNode.
-         *
- */ - @Nullable - public final Node right; - - public RangeNode(int startOffset, int length, short flags, Node left, Node right) { - super(startOffset, length); - this.flags = flags; - this.left = left; - this.right = right; - } - - public boolean isExcludeEnd() { - return RangeFlags.isExcludeEnd(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.left != null) { - this.left.accept(visitor); - } - if (this.right != null) { - this.right.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.left, this.right }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRangeNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("RangeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("left: "); - builder.append(this.left == null ? "null\n" : this.left.toString(nextIndent)); - builder.append(nextIndent); - builder.append("right: "); - builder.append(this.right == null ? "null\n" : this.right.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a rational number literal.
-     *
-     *     1.0r
-     *     ^^^^
-     *
- */ - public static final class RationalNode extends Node { - public final short flags; - /** - * 
-         * The numerator of the rational number.
-         *
-         *     1.5r # numerator 3
-         *
- */ - public final Object numerator; - /** - * 
-         * The denominator of the rational number.
-         *
-         *     1.5r # denominator 2
-         *
- */ - public final Object denominator; - - public RationalNode(int startOffset, int length, short flags, Object numerator, Object denominator) { - super(startOffset, length); - this.flags = flags; - this.numerator = numerator; - this.denominator = denominator; - } - - public boolean isBinary() { - return IntegerBaseFlags.isBinary(flags); - } - - public boolean isDecimal() { - return IntegerBaseFlags.isDecimal(flags); - } - - public boolean isOctal() { - return IntegerBaseFlags.isOctal(flags); - } - - public boolean isHexadecimal() { - return IntegerBaseFlags.isHexadecimal(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRationalNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("IntegerBaseFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("numerator: "); - builder.append(this.numerator); - builder.append('\n'); - builder.append(nextIndent); - builder.append("denominator: "); - builder.append(this.denominator); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `redo` keyword.
-     *
-     *     redo
-     *     ^^^^
-     *
- */ - public static final class RedoNode extends Node { - - public RedoNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRedoNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents a regular expression literal with no interpolation.
-     *
-     *     /foo/i
-     *     ^^^^^^
-     *
- */ - public static final class RegularExpressionNode extends Node { - public final short flags; - public final byte[] unescaped; - - public RegularExpressionNode(int startOffset, int length, short flags, byte[] unescaped) { - super(startOffset, length); - this.flags = flags; - this.unescaped = unescaped; - } - - public boolean isIgnoreCase() { - return RegularExpressionFlags.isIgnoreCase(flags); - } - - public boolean isExtended() { - return RegularExpressionFlags.isExtended(flags); - } - - public boolean isMultiLine() { - return RegularExpressionFlags.isMultiLine(flags); - } - - public boolean isOnce() { - return RegularExpressionFlags.isOnce(flags); - } - - public boolean isEucJp() { - return RegularExpressionFlags.isEucJp(flags); - } - - public boolean isAscii8bit() { - return RegularExpressionFlags.isAscii8bit(flags); - } - - public boolean isWindows31j() { - return RegularExpressionFlags.isWindows31j(flags); - } - - public boolean isUtf8() { - return RegularExpressionFlags.isUtf8(flags); - } - - public boolean isForcedUtf8Encoding() { - return RegularExpressionFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return RegularExpressionFlags.isForcedBinaryEncoding(flags); - } - - public boolean isForcedUsAsciiEncoding() { - return RegularExpressionFlags.isForcedUsAsciiEncoding(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRegularExpressionNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("RegularExpressionFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("unescaped: "); - builder.append('"' + new String(this.unescaped, StandardCharsets.UTF_8) + '"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents a required keyword parameter to a method, block, or lambda definition.
-     *
-     *     def a(b: )
-     *           ^^
-     *     end
-     *
- */ - public static final class RequiredKeywordParameterNode extends Node { - public final short flags; - public final org.jruby.RubySymbol name; - - public RequiredKeywordParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { - super(startOffset, length); - this.flags = flags; - this.name = name; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRequiredKeywordParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents a required parameter to a method, block, or lambda definition.
-     *
-     *     def a(b)
-     *           ^
-     *     end
-     *
- */ - public static final class RequiredParameterNode extends Node { - public final short flags; - public final org.jruby.RubySymbol name; - - public RequiredParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { - super(startOffset, length); - this.flags = flags; - this.name = name; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRequiredParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append('"').append(this.name).append('"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents an expression modified with a rescue.
-     *
-     *     foo rescue nil
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class RescueModifierNode extends Node { - public final Node expression; - public final Node rescue_expression; - - public RescueModifierNode(int startOffset, int length, Node expression, Node rescue_expression) { - super(startOffset, length); - this.expression = expression; - this.rescue_expression = rescue_expression; - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - this.expression.setNewLineFlag(source, newlineMarked); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.expression.accept(visitor); - this.rescue_expression.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.expression, this.rescue_expression }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRescueModifierNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("expression: "); - builder.append(this.expression.toString(nextIndent)); - builder.append(nextIndent); - builder.append("rescue_expression: "); - builder.append(this.rescue_expression.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a rescue statement.
-     *
-     *     begin
-     *     rescue Foo, *splat, Bar => ex
-     *       foo
-     *     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-     *     end
-     *
-     * `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field.
-     *
- */ - public static final class RescueNode extends Node { - public final Node[] exceptions; - @Nullable - @UnionType({ LocalVariableTargetNode.class, InstanceVariableTargetNode.class, ClassVariableTargetNode.class, GlobalVariableTargetNode.class, ConstantTargetNode.class, ConstantPathTargetNode.class, CallTargetNode.class, IndexTargetNode.class }) - public final Node reference; - @Nullable - public final StatementsNode statements; - @Nullable - public final RescueNode subsequent; - - public RescueNode(int startOffset, int length, Node[] exceptions, Node reference, StatementsNode statements, RescueNode subsequent) { - super(startOffset, length); - this.exceptions = exceptions; - this.reference = reference; - this.statements = statements; - this.subsequent = subsequent; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.exceptions) { - child.accept(visitor); - } - if (this.reference != null) { - this.reference.accept(visitor); - } - if (this.statements != null) { - this.statements.accept(visitor); - } - if (this.subsequent != null) { - this.subsequent.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.exceptions)); - childNodes.add(this.reference); - childNodes.add(this.statements); - childNodes.add(this.subsequent); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRescueNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("exceptions: "); - builder.append('\n'); - for (Node child : this.exceptions) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("reference: "); - builder.append(this.reference == null ? "null\n" : this.reference.toString(nextIndent)); - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - builder.append(nextIndent); - builder.append("subsequent: "); - builder.append(this.subsequent == null ? "null\n" : this.subsequent.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a rest parameter to a method, block, or lambda definition.
-     *
-     *     def a(*b)
-     *           ^^
-     *     end
-     *
- */ - public static final class RestParameterNode extends Node { - public final short flags; - @Nullable - public final org.jruby.RubySymbol name; - - public RestParameterNode(int startOffset, int length, short flags, org.jruby.RubySymbol name) { - super(startOffset, length); - this.flags = flags; - this.name = name; - } - - public boolean isRepeatedParameter() { - return ParameterFlags.isRepeatedParameter(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRestParameterNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ParameterFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("name: "); - builder.append(this.name == null ? "null" : "\"" + this.name + "\""); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `retry` keyword.
-     *
-     *     retry
-     *     ^^^^^
-     *
- */ - public static final class RetryNode extends Node { - - public RetryNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitRetryNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `return` keyword.
-     *
-     *     return 1
-     *     ^^^^^^^^
-     *
- */ - public static final class ReturnNode extends Node { - @Nullable - public final ArgumentsNode arguments; - - public ReturnNode(int startOffset, int length, ArgumentsNode arguments) { - super(startOffset, length); - this.arguments = arguments; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.arguments != null) { - this.arguments.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.arguments }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitReturnNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the `self` keyword.
-     *
-     *     self
-     *     ^^^^
-     *
- */ - public static final class SelfNode extends Node { - - public SelfNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSelfNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
-     *
-     *     # shareable_constant_value: literal
-     *     C = { a: 1 }
-     *     ^^^^^^^^^^^^
-     *
- */ - public static final class ShareableConstantNode extends Node { - public final short flags; - /** - * 
-         * The constant write that should be modified with the shareability state.
-         *
- */ - @UnionType({ ConstantWriteNode.class, ConstantAndWriteNode.class, ConstantOrWriteNode.class, ConstantOperatorWriteNode.class, ConstantPathWriteNode.class, ConstantPathAndWriteNode.class, ConstantPathOrWriteNode.class, ConstantPathOperatorWriteNode.class }) - public final Node write; - - public ShareableConstantNode(int startOffset, int length, short flags, Node write) { - super(startOffset, length); - this.flags = flags; - this.write = write; - } - - public boolean isLiteral() { - return ShareableConstantNodeFlags.isLiteral(flags); - } - - public boolean isExperimentalEverything() { - return ShareableConstantNodeFlags.isExperimentalEverything(flags); - } - - public boolean isExperimentalCopy() { - return ShareableConstantNodeFlags.isExperimentalCopy(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.write.accept(visitor); - } - - public Node[] childNodes() { - return new Node[] { this.write }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitShareableConstantNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("ShareableConstantNodeFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("write: "); - builder.append(this.write.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a singleton class declaration involving the `class` keyword.
-     *
-     *     class << self end
-     *     ^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class SingletonClassNode extends Node { - public final org.jruby.RubySymbol[] locals; - public final Node expression; - @Nullable - @UnionType({ StatementsNode.class, BeginNode.class }) - public final Node body; - - public SingletonClassNode(int startOffset, int length, org.jruby.RubySymbol[] locals, Node expression, Node body) { - super(startOffset, length); - this.locals = locals; - this.expression = expression; - this.body = body; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.expression.accept(visitor); - if (this.body != null) { - this.body.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.expression, this.body }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSingletonClassNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("locals: "); - builder.append('\n'); - for (org.jruby.RubySymbol constant : this.locals) { - builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n'); - } - builder.append(nextIndent); - builder.append("expression: "); - builder.append(this.expression.toString(nextIndent)); - builder.append(nextIndent); - builder.append("body: "); - builder.append(this.body == null ? "null\n" : this.body.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `__ENCODING__` keyword.
-     *
-     *     __ENCODING__
-     *     ^^^^^^^^^^^^
-     *
- */ - public static final class SourceEncodingNode extends Node { - - public SourceEncodingNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSourceEncodingNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `__FILE__` keyword.
-     *
-     *     __FILE__
-     *     ^^^^^^^^
-     *
- */ - public static final class SourceFileNode extends Node { - public final short flags; - /** - * 
-         * Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
-         *
- */ - public final byte[] filepath; - - public SourceFileNode(int startOffset, int length, short flags, byte[] filepath) { - super(startOffset, length); - this.flags = flags; - this.filepath = filepath; - } - - public boolean isForcedUtf8Encoding() { - return StringFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return StringFlags.isForcedBinaryEncoding(flags); - } - - public boolean isFrozen() { - return StringFlags.isFrozen(flags); - } - - public boolean isMutable() { - return StringFlags.isMutable(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSourceFileNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("StringFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("filepath: "); - builder.append('"' + new String(this.filepath, StandardCharsets.UTF_8) + '"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `__LINE__` keyword.
-     *
-     *     __LINE__
-     *     ^^^^^^^^
-     *
- */ - public static final class SourceLineNode extends Node { - - public SourceLineNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSourceLineNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the splat operator.
-     *
-     *     [*a]
-     *      ^^
-     *
- */ - public static final class SplatNode extends Node { - @Nullable - public final Node expression; - - public SplatNode(int startOffset, int length, Node expression) { - super(startOffset, length); - this.expression = expression; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.expression != null) { - this.expression.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.expression }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSplatNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("expression: "); - builder.append(this.expression == null ? "null\n" : this.expression.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a set of statements contained within some scope.
-     *
-     *     foo; bar; baz
-     *     ^^^^^^^^^^^^^
-     *
- */ - public static final class StatementsNode extends Node { - public final Node[] body; - - public StatementsNode(int startOffset, int length, Node[] body) { - super(startOffset, length); - this.body = body; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.body) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.body)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitStatementsNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("body: "); - builder.append('\n'); - for (Node child : this.body) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
-     *
-     *     "foo"
-     *     ^^^^^
-     *
-     *     %w[foo]
-     *        ^^^
-     *
-     *     "foo #{bar} baz"
-     *      ^^^^      ^^^^
-     *
- */ - public static final class StringNode extends Node { - public final short flags; - public final byte[] unescaped; - - public StringNode(int startOffset, int length, short flags, byte[] unescaped) { - super(startOffset, length); - this.flags = flags; - this.unescaped = unescaped; - } - - public boolean isForcedUtf8Encoding() { - return StringFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return StringFlags.isForcedBinaryEncoding(flags); - } - - public boolean isFrozen() { - return StringFlags.isFrozen(flags); - } - - public boolean isMutable() { - return StringFlags.isMutable(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitStringNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("StringFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("unescaped: "); - builder.append('"' + new String(this.unescaped, StandardCharsets.UTF_8) + '"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `super` keyword with parentheses or arguments.
-     *
-     *     super()
-     *     ^^^^^^^
-     *
-     *     super foo, bar
-     *     ^^^^^^^^^^^^^^
-     *
- */ - public static final class SuperNode extends Node { - @Nullable - public final ArgumentsNode arguments; - @Nullable - @UnionType({ BlockNode.class, BlockArgumentNode.class }) - public final Node block; - - public SuperNode(int startOffset, int length, ArgumentsNode arguments, Node block) { - super(startOffset, length); - this.arguments = arguments; - this.block = block; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.arguments != null) { - this.arguments.accept(visitor); - } - if (this.block != null) { - this.block.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.arguments, this.block }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSuperNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - builder.append(nextIndent); - builder.append("block: "); - builder.append(this.block == null ? "null\n" : this.block.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents a symbol literal or a symbol contained within a `%i` list.
-     *
-     *     :foo
-     *     ^^^^
-     *
-     *     %i[foo]
-     *        ^^^
-     *
- */ - public static final class SymbolNode extends Node { - public final short flags; - public final byte[] unescaped; - - public SymbolNode(int startOffset, int length, short flags, byte[] unescaped) { - super(startOffset, length); - this.flags = flags; - this.unescaped = unescaped; - } - - public boolean isForcedUtf8Encoding() { - return SymbolFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return SymbolFlags.isForcedBinaryEncoding(flags); - } - - public boolean isForcedUsAsciiEncoding() { - return SymbolFlags.isForcedUsAsciiEncoding(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitSymbolNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("SymbolFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("unescaped: "); - builder.append('"' + new String(this.unescaped, StandardCharsets.UTF_8) + '"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the literal `true` keyword.
-     *
-     *     true
-     *     ^^^^
-     *
- */ - public static final class TrueNode extends Node { - - public TrueNode(int startOffset, int length) { - super(startOffset, length); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitTrueNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `undef` keyword.
-     *
-     *     undef :foo, :bar, :baz
-     *     ^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class UndefNode extends Node { - @UnionType({ SymbolNode.class, InterpolatedSymbolNode.class }) - public final Node[] names; - - public UndefNode(int startOffset, int length, Node[] names) { - super(startOffset, length); - this.names = names; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.names) { - child.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.names)); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitUndefNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("names: "); - builder.append('\n'); - for (Node child : this.names) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `unless` keyword, either in the block form or the modifier form.
-     *
-     *     bar unless foo
-     *     ^^^^^^^^^^^^^^
-     *
-     *     unless foo then bar end
-     *     ^^^^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class UnlessNode extends Node { - /** - * 
-         * The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-         *
-         *     unless cond then bar end
-         *            ^^^^
-         *
-         *     bar unless cond
-         *                ^^^^
-         *
- */ - public final Node predicate; - /** - * 
-         * The body of statements that will executed if the unless condition is
-         * falsey. Will be `nil` if no body is provided.
-         *
-         *     unless cond then bar end
-         *                      ^^^
-         *
- */ - @Nullable - public final StatementsNode statements; - /** - * 
-         * The else clause of the unless expression, if present.
-         *
-         *     unless cond then bar else baz end
-         *                          ^^^^^^^^
-         *
- */ - @Nullable - public final ElseNode else_clause; - - public UnlessNode(int startOffset, int length, Node predicate, StatementsNode statements, ElseNode else_clause) { - super(startOffset, length); - this.predicate = predicate; - this.statements = statements; - this.else_clause = else_clause; - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - this.predicate.setNewLineFlag(source, newlineMarked); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.predicate.accept(visitor); - if (this.statements != null) { - this.statements.accept(visitor); - } - if (this.else_clause != null) { - this.else_clause.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.predicate, this.statements, this.else_clause }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitUnlessNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("predicate: "); - builder.append(this.predicate.toString(nextIndent)); - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - builder.append(nextIndent); - builder.append("else_clause: "); - builder.append(this.else_clause == null ? "null\n" : this.else_clause.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `until` keyword, either in the block form or the modifier form.
-     *
-     *     bar until foo
-     *     ^^^^^^^^^^^^^
-     *
-     *     until foo do bar end
-     *     ^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class UntilNode extends Node { - public final short flags; - public final Node predicate; - @Nullable - public final StatementsNode statements; - - public UntilNode(int startOffset, int length, short flags, Node predicate, StatementsNode statements) { - super(startOffset, length); - this.flags = flags; - this.predicate = predicate; - this.statements = statements; - } - - public boolean isBeginModifier() { - return LoopFlags.isBeginModifier(flags); - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - this.predicate.setNewLineFlag(source, newlineMarked); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.predicate.accept(visitor); - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.predicate, this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitUntilNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("LoopFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("predicate: "); - builder.append(this.predicate.toString(nextIndent)); - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `when` keyword within a case statement.
-     *
-     *     case true
-     *     when true
-     *     ^^^^^^^^^
-     *     end
-     *
- */ - public static final class WhenNode extends Node { - public final Node[] conditions; - @Nullable - public final StatementsNode statements; - - public WhenNode(int startOffset, int length, Node[] conditions, StatementsNode statements) { - super(startOffset, length); - this.conditions = conditions; - this.statements = statements; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - for (Nodes.Node child : this.conditions) { - child.accept(visitor); - } - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - ArrayList childNodes = new ArrayList<>(); - childNodes.addAll(Arrays.asList(this.conditions)); - childNodes.add(this.statements); - return childNodes.toArray(EMPTY_ARRAY); - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitWhenNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - String nextNextIndent = nextIndent + " "; - builder.append(nextIndent); - builder.append("conditions: "); - builder.append('\n'); - for (Node child : this.conditions) { - builder.append(nextNextIndent).append(child.toString(nextNextIndent)); - } - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `while` keyword, either in the block form or the modifier form.
-     *
-     *     bar while foo
-     *     ^^^^^^^^^^^^^
-     *
-     *     while foo do bar end
-     *     ^^^^^^^^^^^^^^^^^^^^
-     *
- */ - public static final class WhileNode extends Node { - public final short flags; - public final Node predicate; - @Nullable - public final StatementsNode statements; - - public WhileNode(int startOffset, int length, short flags, Node predicate, StatementsNode statements) { - super(startOffset, length); - this.flags = flags; - this.predicate = predicate; - this.statements = statements; - } - - public boolean isBeginModifier() { - return LoopFlags.isBeginModifier(flags); - } - - @Override - public void setNewLineFlag(Source source, boolean[] newlineMarked) { - this.predicate.setNewLineFlag(source, newlineMarked); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - this.predicate.accept(visitor); - if (this.statements != null) { - this.statements.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.predicate, this.statements }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitWhileNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("LoopFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("predicate: "); - builder.append(this.predicate.toString(nextIndent)); - builder.append(nextIndent); - builder.append("statements: "); - builder.append(this.statements == null ? "null\n" : this.statements.toString(nextIndent)); - return builder.toString(); - } - } - - /** - * 
-     * Represents an xstring literal with no interpolation.
-     *
-     *     `foo`
-     *     ^^^^^
-     *
- */ - public static final class XStringNode extends Node { - public final short flags; - public final byte[] unescaped; - - public XStringNode(int startOffset, int length, short flags, byte[] unescaped) { - super(startOffset, length); - this.flags = flags; - this.unescaped = unescaped; - } - - public boolean isForcedUtf8Encoding() { - return EncodingFlags.isForcedUtf8Encoding(flags); - } - - public boolean isForcedBinaryEncoding() { - return EncodingFlags.isForcedBinaryEncoding(flags); - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - } - - public Node[] childNodes() { - return EMPTY_ARRAY; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitXStringNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("EncodingFlags: "); - builder.append(flags); - builder.append('\n'); - builder.append(nextIndent); - builder.append("unescaped: "); - builder.append('"' + new String(this.unescaped, StandardCharsets.UTF_8) + '"'); - builder.append('\n'); - return builder.toString(); - } - } - - /** - * 
-     * Represents the use of the `yield` keyword.
-     *
-     *     yield 1
-     *     ^^^^^^^
-     *
- */ - public static final class YieldNode extends Node { - @Nullable - public final ArgumentsNode arguments; - - public YieldNode(int startOffset, int length, ArgumentsNode arguments) { - super(startOffset, length); - this.arguments = arguments; - } - - public void visitChildNodes(AbstractNodeVisitor visitor) { - if (this.arguments != null) { - this.arguments.accept(visitor); - } - } - - public Node[] childNodes() { - return new Node[] { this.arguments }; - } - - public T accept(AbstractNodeVisitor visitor) { - return visitor.visitYieldNode(this); - } - - @Override - protected String toString(String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(this.getClass().getSimpleName()); - if (hasNewLineFlag()) { - builder.append("[Li]"); - } - builder.append('\n'); - String nextIndent = indent + " "; - builder.append(nextIndent); - builder.append("arguments: "); - builder.append(this.arguments == null ? "null\n" : this.arguments.toString(nextIndent)); - return builder.toString(); - } - } - - public enum ErrorType { - ALIAS_ARGUMENT, - ALIAS_ARGUMENT_NUMBERED_REFERENCE, - AMPAMPEQ_MULTI_ASSIGN, - ARGUMENT_AFTER_BLOCK, - ARGUMENT_AFTER_FORWARDING_ELLIPSES, - ARGUMENT_BARE_HASH, - ARGUMENT_BLOCK_FORWARDING, - ARGUMENT_BLOCK_MULTI, - ARGUMENT_CONFLICT_AMPERSAND, - ARGUMENT_CONFLICT_STAR, - ARGUMENT_CONFLICT_STAR_STAR, - ARGUMENT_FORMAL_CLASS, - ARGUMENT_FORMAL_CONSTANT, - ARGUMENT_FORMAL_GLOBAL, - ARGUMENT_FORMAL_IVAR, - ARGUMENT_FORWARDING_UNBOUND, - ARGUMENT_NO_FORWARDING_AMPERSAND, - ARGUMENT_NO_FORWARDING_ELLIPSES, - ARGUMENT_NO_FORWARDING_STAR, - ARGUMENT_NO_FORWARDING_STAR_STAR, - ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT, - ARGUMENT_SPLAT_AFTER_SPLAT, - ARGUMENT_TERM_PAREN, - ARGUMENT_UNEXPECTED_BLOCK, - ARRAY_ELEMENT, - ARRAY_EXPRESSION, - ARRAY_EXPRESSION_AFTER_STAR, - ARRAY_SEPARATOR, - ARRAY_TERM, - BEGIN_LONELY_ELSE, - BEGIN_TERM, - BEGIN_UPCASE_BRACE, - BEGIN_UPCASE_TERM, - BEGIN_UPCASE_TOPLEVEL, - BLOCK_PARAM_LOCAL_VARIABLE, - BLOCK_PARAM_PIPE_TERM, - BLOCK_TERM_BRACE, - BLOCK_TERM_END, - CANNOT_PARSE_EXPRESSION, - CANNOT_PARSE_STRING_PART, - CASE_EXPRESSION_AFTER_CASE, - CASE_EXPRESSION_AFTER_WHEN, - CASE_MATCH_MISSING_PREDICATE, - CASE_MISSING_CONDITIONS, - CASE_TERM, - CLASS_IN_METHOD, - CLASS_NAME, - CLASS_SUPERCLASS, - CLASS_TERM, - CLASS_UNEXPECTED_END, - CLASS_VARIABLE_BARE, - CONDITIONAL_ELSIF_PREDICATE, - CONDITIONAL_IF_PREDICATE, - CONDITIONAL_PREDICATE_TERM, - CONDITIONAL_TERM, - CONDITIONAL_TERM_ELSE, - CONDITIONAL_UNLESS_PREDICATE, - CONDITIONAL_UNTIL_PREDICATE, - CONDITIONAL_WHILE_PREDICATE, - CONSTANT_PATH_COLON_COLON_CONSTANT, - DEF_ENDLESS, - DEF_ENDLESS_SETTER, - DEF_NAME, - DEF_PARAMS_TERM, - DEF_PARAMS_TERM_PAREN, - DEF_RECEIVER, - DEF_RECEIVER_TERM, - DEF_TERM, - DEFINED_EXPRESSION, - EMBDOC_TERM, - EMBEXPR_END, - EMBVAR_INVALID, - END_UPCASE_BRACE, - END_UPCASE_TERM, - ESCAPE_INVALID_CONTROL, - ESCAPE_INVALID_CONTROL_REPEAT, - ESCAPE_INVALID_HEXADECIMAL, - ESCAPE_INVALID_META, - ESCAPE_INVALID_META_REPEAT, - ESCAPE_INVALID_UNICODE, - ESCAPE_INVALID_UNICODE_CM_FLAGS, - ESCAPE_INVALID_UNICODE_LIST, - ESCAPE_INVALID_UNICODE_LITERAL, - ESCAPE_INVALID_UNICODE_LONG, - ESCAPE_INVALID_UNICODE_SHORT, - ESCAPE_INVALID_UNICODE_TERM, - EXPECT_ARGUMENT, - EXPECT_EOL_AFTER_STATEMENT, - EXPECT_EXPRESSION_AFTER_AMPAMPEQ, - EXPECT_EXPRESSION_AFTER_COMMA, - EXPECT_EXPRESSION_AFTER_EQUAL, - EXPECT_EXPRESSION_AFTER_LESS_LESS, - EXPECT_EXPRESSION_AFTER_LPAREN, - EXPECT_EXPRESSION_AFTER_OPERATOR, - EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, - EXPECT_EXPRESSION_AFTER_QUESTION, - EXPECT_EXPRESSION_AFTER_SPLAT, - EXPECT_EXPRESSION_AFTER_SPLAT_HASH, - EXPECT_EXPRESSION_AFTER_STAR, - EXPECT_FOR_DELIMITER, - EXPECT_IDENT_REQ_PARAMETER, - EXPECT_IN_DELIMITER, - EXPECT_LPAREN_REQ_PARAMETER, - EXPECT_MESSAGE, - EXPECT_RBRACKET, - EXPECT_RPAREN, - EXPECT_RPAREN_AFTER_MULTI, - EXPECT_RPAREN_REQ_PARAMETER, - EXPECT_SINGLETON_CLASS_DELIMITER, - EXPECT_STRING_CONTENT, - EXPECT_WHEN_DELIMITER, - EXPRESSION_BARE_HASH, - EXPRESSION_NOT_WRITABLE, - EXPRESSION_NOT_WRITABLE_ENCODING, - EXPRESSION_NOT_WRITABLE_FALSE, - EXPRESSION_NOT_WRITABLE_FILE, - EXPRESSION_NOT_WRITABLE_LINE, - EXPRESSION_NOT_WRITABLE_NIL, - EXPRESSION_NOT_WRITABLE_NUMBERED, - EXPRESSION_NOT_WRITABLE_SELF, - EXPRESSION_NOT_WRITABLE_TRUE, - FLOAT_PARSE, - FOR_COLLECTION, - FOR_IN, - FOR_INDEX, - FOR_TERM, - GLOBAL_VARIABLE_BARE, - HASH_EXPRESSION_AFTER_LABEL, - HASH_KEY, - HASH_ROCKET, - HASH_TERM, - HASH_VALUE, - HEREDOC_IDENTIFIER, - HEREDOC_TERM, - INCOMPLETE_QUESTION_MARK, - INCOMPLETE_VARIABLE_CLASS, - INCOMPLETE_VARIABLE_CLASS_3_3, - INCOMPLETE_VARIABLE_INSTANCE, - INCOMPLETE_VARIABLE_INSTANCE_3_3, - INSTANCE_VARIABLE_BARE, - INVALID_BLOCK_EXIT, - INVALID_CHARACTER, - INVALID_COMMA, - INVALID_ENCODING_MAGIC_COMMENT, - INVALID_ESCAPE_CHARACTER, - INVALID_FLOAT_EXPONENT, - INVALID_LOCAL_VARIABLE_READ, - INVALID_LOCAL_VARIABLE_WRITE, - INVALID_MULTIBYTE_CHAR, - INVALID_MULTIBYTE_CHARACTER, - INVALID_MULTIBYTE_ESCAPE, - INVALID_NUMBER_BINARY, - INVALID_NUMBER_DECIMAL, - INVALID_NUMBER_FRACTION, - INVALID_NUMBER_HEXADECIMAL, - INVALID_NUMBER_OCTAL, - INVALID_NUMBER_UNDERSCORE_INNER, - INVALID_NUMBER_UNDERSCORE_TRAILING, - INVALID_PERCENT, - INVALID_PERCENT_EOF, - INVALID_PRINTABLE_CHARACTER, - INVALID_RETRY_AFTER_ELSE, - INVALID_RETRY_AFTER_ENSURE, - INVALID_RETRY_WITHOUT_RESCUE, - INVALID_SYMBOL, - INVALID_VARIABLE_GLOBAL, - INVALID_VARIABLE_GLOBAL_3_3, - INVALID_YIELD, - IT_NOT_ALLOWED_NUMBERED, - IT_NOT_ALLOWED_ORDINARY, - LAMBDA_OPEN, - LAMBDA_TERM_BRACE, - LAMBDA_TERM_END, - LIST_I_LOWER_ELEMENT, - LIST_I_LOWER_TERM, - LIST_I_UPPER_ELEMENT, - LIST_I_UPPER_TERM, - LIST_W_LOWER_ELEMENT, - LIST_W_LOWER_TERM, - LIST_W_UPPER_ELEMENT, - LIST_W_UPPER_TERM, - MALLOC_FAILED, - MIXED_ENCODING, - MODULE_IN_METHOD, - MODULE_NAME, - MODULE_TERM, - MULTI_ASSIGN_MULTI_SPLATS, - MULTI_ASSIGN_UNEXPECTED_REST, - NESTING_TOO_DEEP, - NO_LOCAL_VARIABLE, - NON_ASSOCIATIVE_OPERATOR, - NOT_EXPRESSION, - NUMBER_LITERAL_UNDERSCORE, - NUMBERED_PARAMETER_INNER_BLOCK, - NUMBERED_PARAMETER_IT, - NUMBERED_PARAMETER_ORDINARY, - NUMBERED_PARAMETER_OUTER_BLOCK, - OPERATOR_MULTI_ASSIGN, - OPERATOR_WRITE_ARGUMENTS, - OPERATOR_WRITE_BLOCK, - PARAMETER_ASSOC_SPLAT_MULTI, - PARAMETER_BLOCK_MULTI, - PARAMETER_CIRCULAR, - PARAMETER_FORWARDING_AFTER_REST, - PARAMETER_METHOD_NAME, - PARAMETER_NAME_DUPLICATED, - PARAMETER_NO_DEFAULT, - PARAMETER_NO_DEFAULT_KW, - PARAMETER_NUMBERED_RESERVED, - PARAMETER_ORDER, - PARAMETER_SPLAT_MULTI, - PARAMETER_STAR, - PARAMETER_UNEXPECTED_FWD, - PARAMETER_UNEXPECTED_NO_KW, - PARAMETER_WILD_LOOSE_COMMA, - PATTERN_ARRAY_MULTIPLE_RESTS, - PATTERN_CAPTURE_DUPLICATE, - PATTERN_EXPRESSION_AFTER_BRACKET, - PATTERN_EXPRESSION_AFTER_COMMA, - PATTERN_EXPRESSION_AFTER_HROCKET, - PATTERN_EXPRESSION_AFTER_IN, - PATTERN_EXPRESSION_AFTER_KEY, - PATTERN_EXPRESSION_AFTER_PAREN, - PATTERN_EXPRESSION_AFTER_PIN, - PATTERN_EXPRESSION_AFTER_PIPE, - PATTERN_EXPRESSION_AFTER_RANGE, - PATTERN_EXPRESSION_AFTER_REST, - PATTERN_FIND_MISSING_INNER, - PATTERN_HASH_IMPLICIT, - PATTERN_HASH_KEY, - PATTERN_HASH_KEY_DUPLICATE, - PATTERN_HASH_KEY_INTERPOLATED, - PATTERN_HASH_KEY_LABEL, - PATTERN_HASH_KEY_LOCALS, - PATTERN_IDENT_AFTER_HROCKET, - PATTERN_LABEL_AFTER_COMMA, - PATTERN_REST, - PATTERN_TERM_BRACE, - PATTERN_TERM_BRACKET, - PATTERN_TERM_PAREN, - PIPEPIPEEQ_MULTI_ASSIGN, - REGEXP_ENCODING_OPTION_MISMATCH, - REGEXP_INCOMPAT_CHAR_ENCODING, - REGEXP_INVALID_UNICODE_RANGE, - REGEXP_NON_ESCAPED_MBC, - REGEXP_PARSE_ERROR, - REGEXP_TERM, - REGEXP_UNKNOWN_OPTIONS, - REGEXP_UTF8_CHAR_NON_UTF8_REGEXP, - RESCUE_EXPRESSION, - RESCUE_MODIFIER_VALUE, - RESCUE_TERM, - RESCUE_VARIABLE, - RETURN_INVALID, - SCRIPT_NOT_FOUND, - SINGLETON_FOR_LITERALS, - STATEMENT_ALIAS, - STATEMENT_POSTEXE_END, - STATEMENT_PREEXE_BEGIN, - STATEMENT_UNDEF, - STRING_CONCATENATION, - STRING_INTERPOLATED_TERM, - STRING_LITERAL_EOF, - STRING_LITERAL_TERM, - SYMBOL_INVALID, - SYMBOL_TERM_DYNAMIC, - SYMBOL_TERM_INTERPOLATED, - TERNARY_COLON, - TERNARY_EXPRESSION_FALSE, - TERNARY_EXPRESSION_TRUE, - UNARY_DISALLOWED, - UNARY_RECEIVER, - UNDEF_ARGUMENT, - UNEXPECTED_BLOCK_ARGUMENT, - UNEXPECTED_INDEX_BLOCK, - UNEXPECTED_INDEX_KEYWORDS, - UNEXPECTED_LABEL, - UNEXPECTED_MULTI_WRITE, - UNEXPECTED_RANGE_OPERATOR, - UNEXPECTED_SAFE_NAVIGATION, - UNEXPECTED_TOKEN_CLOSE_CONTEXT, - UNEXPECTED_TOKEN_IGNORE, - UNTIL_TERM, - VOID_EXPRESSION, - WHILE_TERM, - WRITE_TARGET_IN_METHOD, - WRITE_TARGET_READONLY, - WRITE_TARGET_UNEXPECTED, - XSTRING_TERM, - } - - public static ErrorType[] ERROR_TYPES = ErrorType.values(); - - public enum WarningType { - AMBIGUOUS_BINARY_OPERATOR, - AMBIGUOUS_FIRST_ARGUMENT_MINUS, - AMBIGUOUS_FIRST_ARGUMENT_PLUS, - AMBIGUOUS_PREFIX_AMPERSAND, - AMBIGUOUS_PREFIX_STAR, - AMBIGUOUS_PREFIX_STAR_STAR, - AMBIGUOUS_SLASH, - COMPARISON_AFTER_COMPARISON, - DOT_DOT_DOT_EOL, - EQUAL_IN_CONDITIONAL, - EQUAL_IN_CONDITIONAL_3_3, - END_IN_METHOD, - DUPLICATED_HASH_KEY, - DUPLICATED_WHEN_CLAUSE, - FLOAT_OUT_OF_RANGE, - IGNORED_FROZEN_STRING_LITERAL, - INDENTATION_MISMATCH, - INTEGER_IN_FLIP_FLOP, - INVALID_CHARACTER, - INVALID_MAGIC_COMMENT_VALUE, - INVALID_NUMBERED_REFERENCE, - KEYWORD_EOL, - LITERAL_IN_CONDITION_DEFAULT, - LITERAL_IN_CONDITION_VERBOSE, - SHAREABLE_CONSTANT_VALUE_LINE, - SHEBANG_CARRIAGE_RETURN, - UNEXPECTED_CARRIAGE_RETURN, - UNREACHABLE_STATEMENT, - UNUSED_LOCAL_VARIABLE, - VOID_STATEMENT, - } - - public static WarningType[] WARNING_TYPES = WarningType.values(); -} -// @formatter:on diff --git a/src/main/java/org/prism/ParseResult.java b/src/main/java/org/prism/ParseResult.java deleted file mode 100644 index 144ea16..0000000 --- a/src/main/java/org/prism/ParseResult.java +++ /dev/null @@ -1,83 +0,0 @@ -package org.prism; - -// @formatter:off -public final class ParseResult { - - public static final class MagicComment { - public final Nodes.Location keyLocation; - public final Nodes.Location valueLocation; - - public MagicComment(Nodes.Location keyLocation, Nodes.Location valueLocation) { - this.keyLocation = keyLocation; - this.valueLocation = valueLocation; - } - } - - public enum ErrorLevel { - /** For errors that should raise SyntaxError. */ - ERROR_SYNTAX, - - /** For errors that should raise ArgumentError. */ - ERROR_ARGUMENT, - - /** For errors that should raise LoadError. */ - ERROR_LOAD, - } - - public static ErrorLevel[] ERROR_LEVELS = ErrorLevel.values(); - - public static final class Error { - public final Nodes.ErrorType type; - public final String message; - public final Nodes.Location location; - public final ErrorLevel level; - - public Error(Nodes.ErrorType type, String message, Nodes.Location location, ErrorLevel level) { - this.type = type; - this.message = message; - this.location = location; - this.level = level; - } - } - - public enum WarningLevel { - /** For warnings which should be emitted if $VERBOSE != nil. */ - WARNING_DEFAULT, - - /** For warnings which should be emitted if $VERBOSE == true. */ - WARNING_VERBOSE - } - - public static WarningLevel[] WARNING_LEVELS = WarningLevel.values(); - - public static final class Warning { - public final Nodes.WarningType type; - public final String message; - public final Nodes.Location location; - public final WarningLevel level; - - public Warning(Nodes.WarningType type, String message, Nodes.Location location, WarningLevel level) { - this.type = type; - this.message = message; - this.location = location; - this.level = level; - } - } - - public final Nodes.Node value; - public final MagicComment[] magicComments; - public final Nodes.Location dataLocation; - public final Error[] errors; - public final Warning[] warnings; - public final Nodes.Source source; - - public ParseResult(Nodes.Node value, MagicComment[] magicComments, Nodes.Location dataLocation, Error[] errors, Warning[] warnings, Nodes.Source source) { - this.value = value; - this.magicComments = magicComments; - this.dataLocation = dataLocation; - this.errors = errors; - this.warnings = warnings; - this.source = source; - } -} -// @formatter:on diff --git a/src/main/java/org/prism/Parser.java b/src/main/java/org/prism/Parser.java deleted file mode 100644 index 717c3e5..0000000 --- a/src/main/java/org/prism/Parser.java +++ /dev/null @@ -1,16 +0,0 @@ -package org.prism; - -public abstract class Parser { - - @SuppressWarnings("restricted") - public static void loadLibrary(String path) { - System.load(path); - } - - public static native byte[] parseAndSerialize(byte[] source, byte[] options); - - public static byte[] parseAndSerialize(byte[] source) { - return parseAndSerialize(source, null); - } - -} diff --git a/src/main/java/org/prism/ParsingOptions.java b/src/main/java/org/prism/ParsingOptions.java deleted file mode 100644 index ff2e995..0000000 --- a/src/main/java/org/prism/ParsingOptions.java +++ /dev/null @@ -1,196 +0,0 @@ -package org.prism; - -import java.io.ByteArrayOutputStream; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.EnumSet; - -// @formatter:off -public abstract class ParsingOptions { - /** - * The version of Ruby syntax that we should be parsing with. - * See pm_options_version_t in include/prism/options.h. - */ - public enum SyntaxVersion { - LATEST(0), - V3_3(1), - V3_4(2); - - private final int value; - - SyntaxVersion(int value) { - this.value = value; - } - - public byte getValue() { - return (byte) value; - } - } - - /** - * The command line options that can be passed to the parser. - * See PM_OPTIONS_COMMAND_LINE_* in include/prism/options.h. - * - * NOTE: positions should match PM_OPTIONS_COMMAND_LINE_* constants values - */ - public enum CommandLine { A, E, L, N, P, X }; - - /** - * The forwarding options for a given scope in the parser. - */ - public enum Forwarding { - NONE(0), - POSITIONAL(1), - KEYWORD(2), - BLOCK(4), - ALL(8); - - private final int value; - - Forwarding(int value) { - this.value = value; - } - - public byte getValue() { - return (byte) value; - } - }; - - /** - * Represents a scope in the parser. - */ - public static class Scope { - private byte[][] locals; - private Forwarding[] forwarding; - - Scope(byte[][] locals) { - this(locals, new Forwarding[0]); - } - - Scope(Forwarding[] forwarding) { - this(new byte[0][], forwarding); - } - - Scope(byte[][] locals, Forwarding[] forwarding) { - this.locals = locals; - this.forwarding = forwarding; - } - - public byte[][] getLocals() { - return locals; - } - - public int getForwarding() { - int value = 0; - for (Forwarding f : forwarding) { - value |= f.getValue(); - } - return value; - } - } - - public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boolean frozenStringLiteral, EnumSet commandLine, SyntaxVersion version, boolean encodingLocked, boolean mainScript, boolean partialScript, byte[][][] scopes) { - Scope[] normalizedScopes = new Scope[scopes.length]; - for (int i = 0; i < scopes.length; i++) { - normalizedScopes[i] = new Scope(scopes[i]); - } - - return serialize(filepath, line, encoding, frozenStringLiteral, commandLine, version, encodingLocked, mainScript, partialScript, normalizedScopes); - } - - /** - * Serialize parsing options into byte array. - * - * @param filepath the name of the file that is currently being parsed - * @param line the line within the file that the parser starts on. This value is 1-indexed - * @param encoding the name of the encoding that the source file is in - * @param frozenStringLiteral whether the frozen string literal option has been set - * @param commandLine the set of flags that were set on the command line - * @param version code of Ruby version which syntax will be used to parse - * @param encodingLocked whether the encoding is locked (should almost always be false) - * @param mainScript whether the file is the main script - * @param partialScript whether the file is a partial script - * @param scopes scopes surrounding the code that is being parsed with local variable names defined in every scope - * ordered from the outermost scope to the innermost one - */ - public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boolean frozenStringLiteral, EnumSet commandLine, SyntaxVersion version, boolean encodingLocked, boolean mainScript, boolean partialScript, Scope[] scopes) { - final ByteArrayOutputStream output = new ByteArrayOutputStream(); - - // filepath - write(output, serializeInt(filepath.length)); - write(output, filepath); - - // line - write(output, serializeInt(line)); - - // encoding - write(output, serializeInt(encoding.length)); - write(output, encoding); - - // frozenStringLiteral - output.write(frozenStringLiteral ? 1 : 0); - - // command line - output.write(serializeEnumSet(commandLine)); - - // version - output.write(version.getValue()); - - // encodingLocked - output.write(encodingLocked ? 1 : 0); - - // mainScript - output.write(mainScript ? 1 : 0); - - // partialScript - output.write(partialScript ? 1 : 0); - - // freeze - output.write(0); - - // scopes - - // number of scopes - write(output, serializeInt(scopes.length)); - - // local variables in each scope - for (Scope scope : scopes) { - byte[][] locals = scope.getLocals(); - - // number of locals - write(output, serializeInt(locals.length)); - - // forwarding flags - output.write(scope.getForwarding()); - - // locals - for (byte[] local : locals) { - write(output, serializeInt(local.length)); - write(output, local); - } - } - - return output.toByteArray(); - } - - private static void write(ByteArrayOutputStream output, byte[] bytes) { - // Note: we cannot use output.writeBytes(local) because that's Java 11 - output.write(bytes, 0, bytes.length); - } - - private static > byte serializeEnumSet(EnumSet set) { - byte result = 0; - for (T value : set) { - assert (1 << value.ordinal()) <= Byte.MAX_VALUE; - result |= (byte) (1 << value.ordinal()); - } - return result; - } - - private static byte[] serializeInt(int n) { - ByteBuffer buffer = ByteBuffer.allocate(4).order(ByteOrder.nativeOrder()); - buffer.putInt(n); - return buffer.array(); - } -} -// @formatter:on From 745df287ded5f537a1a210e6c2ae11db2bf9e883 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 21 Jan 2026 19:34:13 -0600 Subject: [PATCH 03/21] Use a release version of JRuby --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index c9b7c93..11beba6 100644 --- a/pom.xml +++ b/pom.xml @@ -66,7 +66,7 @@ org.jruby jruby-base - 10.0.0.0-SNAPSHOT + 10.0.2.0 com.prism From 548b3a10b654035a55d0294384788b43f2eab489 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 21 Jan 2026 19:35:27 -0600 Subject: [PATCH 04/21] Use new chicory-prism artifact --- pom.xml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pom.xml b/pom.xml index 11beba6..36f730a 100644 --- a/pom.xml +++ b/pom.xml @@ -69,9 +69,9 @@ 10.0.2.0 - com.prism - java-prism - 999-SNAPSHOT + org.jruby + chicory-prism + 0.0.1-SNAPSHOT From aa7627fec8ea889485a4342321d59a243e3d5807 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 21 Jan 2026 19:42:51 -0600 Subject: [PATCH 05/21] Move release plugins to release profile If gpg fails you can't install locally, and the rest are not interesting for local builds. --- pom.xml | 90 ++++++++++++++++++++++++++++++++------------------------- 1 file changed, 51 insertions(+), 39 deletions(-) diff --git a/pom.xml b/pom.xml index 36f730a..ce84547 100644 --- a/pom.xml +++ b/pom.xml @@ -116,45 +116,6 @@ - - org.apache.maven.plugins - maven-gpg-plugin - 1.5 - - - sign-artifacts - verify - - sign - - - - - - maven-source-plugin - - - attach-sources - - jar-no-fork - - - - - - maven-javadoc-plugin - - - attach-javadocs - - jar - - - - - none - - @@ -210,5 +171,56 @@ + + release + + + + maven-gpg-plugin + 1.6 + + + sign-artifacts + verify + + sign + + + + + + --pinentry-mode + loopback + + + + + maven-source-plugin + + + attach-sources + + jar-no-fork + + + + + + maven-javadoc-plugin + + + attach-javadocs + + jar + + + + + none + + + + + From 421936a7a3d59a22925076b7ecb37e5417363d0d Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 21 Jan 2026 19:44:55 -0600 Subject: [PATCH 06/21] Bump version to 2.0 snapshot --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index ce84547..7a41fc0 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ org.jruby jruby-prism jar - 1.5.0 + 2.0.0-SNAPSHOT jruby-prism Java portion of JRuby Prism parser support. From 2845e013664a07d33de10cbf868916a692fbca04 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Wed, 21 Jan 2026 20:06:49 -0600 Subject: [PATCH 07/21] Separate native and wasm parsers Both forms are still in the same provider, but separated into two classes. The ParserProvider logic for JRuby may need some tweaks to support two separate SPIs so this is a first step to isolating them. The native parser will be returned if: * A dynamic library file provided to initialize exists, and * the wasm parser has not been specifically requested. The wasm parser will be returned if: * It was specifically requested, or * a dynamic library that exists has not been provided to initialize. In the future this selection should happen closer to the JRuby level so we can use either or both more easily. --- .../org/jruby/prism/ParserProviderPrism.java | 34 ++++++--- ...{ParserPrism.java => ParserPrismBase.java} | 70 ++++++------------- .../jruby/prism/parser/ParserPrismNative.java | 69 ++++++++++++++++++ .../jruby/prism/parser/ParserPrismWasm.java | 36 ++++++++++ 4 files changed, 150 insertions(+), 59 deletions(-) rename src/main/java/org/jruby/prism/parser/{ParserPrism.java => ParserPrismBase.java} (85%) create mode 100644 src/main/java/org/jruby/prism/parser/ParserPrismNative.java create mode 100644 src/main/java/org/jruby/prism/parser/ParserPrismWasm.java diff --git a/src/main/java/org/jruby/prism/ParserProviderPrism.java b/src/main/java/org/jruby/prism/ParserProviderPrism.java index e81cd3d..07beb81 100644 --- a/src/main/java/org/jruby/prism/ParserProviderPrism.java +++ b/src/main/java/org/jruby/prism/ParserProviderPrism.java @@ -1,31 +1,43 @@ package org.jruby.prism; +import jnr.ffi.LibraryLoader; import org.jruby.Ruby; import org.jruby.ir.builder.IRBuilderFactory; import org.jruby.parser.Parser; +import org.jruby.parser.ParserManager; import org.jruby.parser.ParserProvider; -import org.jruby.prism.parser.ParserPrism; -import org.jruby.prism.parser.ParserBindingPrism; import org.jruby.prism.builder.IRBuilderFactoryPrism; +import org.jruby.prism.parser.ParserBindingPrism; +import org.jruby.prism.parser.ParserPrismNative; +import org.jruby.prism.parser.ParserPrismWasm; -import jnr.ffi.LibraryLoader; +import java.io.File; public class ParserProviderPrism implements ParserProvider { private static ParserBindingPrism prismLibrary; public void initialize(String path) { - if (prismLibrary != null) { - System.out.println("Prism already initialized"); - return; + if (new File(path).exists()) { + if (prismLibrary != null) { + System.out.println("Prism already initialized"); + return; + } + prismLibrary = LibraryLoader.create(ParserBindingPrism.class).load(path); + // We do something extra here as a side-effect which is how we get an UnsatisfiedLinkError + // If the library didn't in fact find the .so or has other loading problems. + ParserBindingPrism.Buffer buffer = new ParserBindingPrism.Buffer(jnr.ffi.Runtime.getRuntime(prismLibrary)); + } else { + prismLibrary = null; } - prismLibrary = LibraryLoader.create(ParserBindingPrism.class).load(path); - // We do something extra here as a side-effect which is how we get an UnsatisfiedLinkError - // If the library didn't in fact find the .so or has other loading problems. - ParserBindingPrism.Buffer buffer = new ParserBindingPrism.Buffer(jnr.ffi.Runtime.getRuntime(prismLibrary)); } public Parser getParser(Ruby runtime) { - return new ParserPrism(runtime, prismLibrary); + if (ParserManager.PARSER_WASM || prismLibrary == null) { + // uninitialized dynamic lib or wasm requested + return new ParserPrismWasm(runtime); + } + + return new ParserPrismNative(runtime, prismLibrary); } public IRBuilderFactory getBuilderFactory() { diff --git a/src/main/java/org/jruby/prism/parser/ParserPrism.java b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java similarity index 85% rename from src/main/java/org/jruby/prism/parser/ParserPrism.java rename to src/main/java/org/jruby/prism/parser/ParserPrismBase.java index f11dee3..58eaf8c 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrism.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java @@ -11,7 +11,6 @@ import org.jruby.ext.coverage.CoverageData; import org.jruby.management.ParserStats; import org.jruby.parser.Parser; -import org.jruby.parser.ParserManager; import org.jruby.parser.ParserType; import org.jruby.parser.StaticScope; import org.jruby.runtime.DynamicScope; @@ -21,10 +20,16 @@ import org.jruby.util.ByteList; import org.jruby.util.CommonByteLists; import org.jruby.util.io.ChannelHelper; -import org.prism.Nodes; -import org.prism.Nodes.*; +import org.prism.Nodes.ArgumentsNode; +import org.prism.Nodes.CallNode; +import org.prism.Nodes.CallNodeFlags; +import org.prism.Nodes.GlobalVariableReadNode; +import org.prism.Nodes.GlobalVariableWriteNode; +import org.prism.Nodes.Node; +import org.prism.Nodes.ProgramNode; +import org.prism.Nodes.StatementsNode; +import org.prism.Nodes.WhileNode; import org.prism.ParsingOptions; -import org.prism.Prism; import java.io.ByteArrayInputStream; import java.io.DataInputStream; @@ -39,16 +44,15 @@ import static org.jruby.parser.ParserType.EVAL; import static org.jruby.parser.ParserType.MAIN; -public class ParserPrism extends Parser { - private boolean parserTiming = org.jruby.util.cli.Options.PARSER_SUMMARY.load(); +public abstract class ParserPrismBase extends Parser { + protected boolean parserTiming = org.jruby.util.cli.Options.PARSER_SUMMARY.load(); - private final ParserBindingPrism prismLibrary; - - public ParserPrism(Ruby runtime, ParserBindingPrism prismLibrary) { + public ParserPrismBase(Ruby runtime) { super(runtime); - this.prismLibrary = prismLibrary; } + protected abstract byte[] parse(byte[] source, int sourceLength, byte[] metadata); + @Override public ParseResult parse(String fileName, int lineNumber, ByteList content, DynamicScope existingScope, ParserType type) { int sourceLength = content.realSize(); @@ -113,10 +117,10 @@ private ParseResult parseInternal(String fileName, DynamicScope blockScope, byte coverageMode = runtime.getCoverageData().getMode(); } - ParseResultPrism result = new ParseResultPrism(fileName, source, (Nodes.ProgramNode) res.value, res.source, encoding, coverageMode); + ParseResultPrism result = new ParseResultPrism(fileName, source, (ProgramNode) res.value, res.source, encoding, coverageMode); if (blockScope != null) { if (type == MAIN) { // update TOPLEVEL_BINDNG - RubySymbol[] locals = ((Nodes.ProgramNode) result.getAST()).locals; + RubySymbol[] locals = ((ProgramNode) result.getAST()).locals; for (int i = 0; i < locals.length; i++) { blockScope.getStaticScope().addVariableThisScope(locals[i].idString()); } @@ -174,36 +178,6 @@ private byte[] loadFully(String fileName, InputStream in) { } } - - private byte[] parse(byte[] source, int sourceLength, byte[] metadata) { - if (ParserManager.PARSER_WASM) return parseChicory(source, sourceLength, metadata); - - long time = 0; - if (parserTiming) time = System.nanoTime(); - - ParserBindingPrism.Buffer buffer = new ParserBindingPrism.Buffer(jnr.ffi.Runtime.getRuntime(prismLibrary)); - prismLibrary.pm_buffer_init(buffer); - prismLibrary.pm_serialize_parse(buffer, source, sourceLength, metadata); - if (parserTiming) { - ParserStats stats = runtime.getParserManager().getParserStats(); - - stats.addPrismTimeCParseSerialize(System.nanoTime() - time); - } - - int length = buffer.length.intValue(); - byte[] src = new byte[length]; - buffer.value.get().get(0, src, 0, length); - - return src; - } - - - private byte[] parseChicory(byte[] source, int sourceLength, byte[] metadata) { - try (Prism prism = new Prism()) { - return prism.serialize(metadata, source, sourceLength); - } - } - // lineNumber (0-indexed) private byte[] generateMetadata(String fileName, int lineNumber, Encoding encoding, DynamicScope scope, ParserType type) { ByteList metadata = new ByteList(); @@ -327,23 +301,23 @@ public IRubyObject getLineStub(ThreadContext context, ParseResult arg, int lineC @Override public ParseResult addGetsLoop(Ruby runtime, ParseResult result, boolean printing, boolean processLineEndings, boolean split) { var context = runtime.getCurrentContext(); - List newBody = new ArrayList<>(); + List newBody = new ArrayList<>(); if (processLineEndings) { - newBody.add(new Nodes.GlobalVariableWriteNode(-1, 0, 0, asSymbol(context, CommonByteLists.DOLLAR_BACKSLASH), + newBody.add(new GlobalVariableWriteNode(-1, 0, 0, asSymbol(context, CommonByteLists.DOLLAR_BACKSLASH), new GlobalVariableReadNode(-1, 0, 0, asSymbol(context, CommonByteLists.DOLLAR_SLASH)))); } - Nodes.GlobalVariableReadNode dollarUnderscore = new GlobalVariableReadNode(-1, 0, 0, asSymbol(context, DOLLAR_UNDERSCORE)); + GlobalVariableReadNode dollarUnderscore = new GlobalVariableReadNode(-1, 0, 0, asSymbol(context, DOLLAR_UNDERSCORE)); - List whileBody = new ArrayList<>(); + List whileBody = new ArrayList<>(); if (processLineEndings) { whileBody.add(new CallNode(-1, 0, 0, (short) 0, dollarUnderscore, asSymbol(context, "chomp!"), null, null)); } if (split) { whileBody.add(new GlobalVariableWriteNode(-1, 0, 0, asSymbol(context, "$F"), - new Nodes.CallNode(-1, 0, 0, (short) 0, dollarUnderscore, asSymbol(context, "split"), null, null))); + new CallNode(-1, 0, 0, (short) 0, dollarUnderscore, asSymbol(context, "split"), null, null))); } StatementsNode stmts = ((ProgramNode) result.getAST()).statements; @@ -362,7 +336,7 @@ public ParseResult addGetsLoop(Ruby runtime, ParseResult result, boolean printin nodes = new Node[newBody.size()]; newBody.toArray(nodes); - Nodes.ProgramNode newRoot = new Nodes.ProgramNode(-1, 0, 0, new RubySymbol[] {}, new StatementsNode(-1, 0, 0, nodes)); + ProgramNode newRoot = new ProgramNode(-1, 0, 0, new RubySymbol[] {}, new StatementsNode(-1, 0, 0, nodes)); ((ParseResultPrism) result).setRoot(newRoot); diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismNative.java b/src/main/java/org/jruby/prism/parser/ParserPrismNative.java new file mode 100644 index 0000000..3404133 --- /dev/null +++ b/src/main/java/org/jruby/prism/parser/ParserPrismNative.java @@ -0,0 +1,69 @@ +package org.jruby.prism.parser; + +import org.jcodings.Encoding; +import org.jcodings.specific.ISO8859_1Encoding; +import org.jruby.ParseResult; +import org.jruby.Ruby; +import org.jruby.RubyArray; +import org.jruby.RubyIO; +import org.jruby.RubyInstanceConfig; +import org.jruby.RubySymbol; +import org.jruby.ext.coverage.CoverageData; +import org.jruby.management.ParserStats; +import org.jruby.parser.Parser; +import org.jruby.parser.ParserManager; +import org.jruby.parser.ParserType; +import org.jruby.parser.StaticScope; +import org.jruby.runtime.DynamicScope; +import org.jruby.runtime.ThreadContext; +import org.jruby.runtime.builtin.IRubyObject; +import org.jruby.runtime.load.LoadServiceResourceInputStream; +import org.jruby.util.ByteList; +import org.jruby.util.CommonByteLists; +import org.jruby.util.io.ChannelHelper; +import org.prism.Nodes; +import org.prism.Nodes.*; +import org.prism.ParsingOptions; +import org.prism.Prism; + +import java.io.ByteArrayInputStream; +import java.io.DataInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static org.jruby.api.Convert.asSymbol; +import static org.jruby.lexer.LexingCommon.DOLLAR_UNDERSCORE; +import static org.jruby.parser.ParserType.EVAL; +import static org.jruby.parser.ParserType.MAIN; + +public class ParserPrismNative extends ParserPrismBase { + private final ParserBindingPrism prismLibrary; + + public ParserPrismNative(Ruby runtime, ParserBindingPrism prismLibrary) { + super(runtime); + this.prismLibrary = prismLibrary; + } + + protected byte[] parse(byte[] source, int sourceLength, byte[] metadata) { + long time = 0; + if (parserTiming) time = System.nanoTime(); + + ParserBindingPrism.Buffer buffer = new ParserBindingPrism.Buffer(jnr.ffi.Runtime.getRuntime(prismLibrary)); + prismLibrary.pm_buffer_init(buffer); + prismLibrary.pm_serialize_parse(buffer, source, sourceLength, metadata); + if (parserTiming) { + ParserStats stats = runtime.getParserManager().getParserStats(); + + stats.addPrismTimeCParseSerialize(System.nanoTime() - time); + } + + int length = buffer.length.intValue(); + byte[] src = new byte[length]; + buffer.value.get().get(0, src, 0, length); + + return src; + } +} diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java new file mode 100644 index 0000000..92ef1a5 --- /dev/null +++ b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java @@ -0,0 +1,36 @@ +package org.jruby.prism.parser; + +import org.jcodings.Encoding; +import org.jcodings.specific.ISO8859_1Encoding; +import org.jruby.*; +import org.jruby.parser.Parser; +import org.jruby.parser.ParserType; +import org.jruby.parser.StaticScope; +import org.jruby.runtime.DynamicScope; +import org.jruby.runtime.ThreadContext; +import org.jruby.runtime.builtin.IRubyObject; +import org.jruby.util.ByteList; +import org.jruby.util.CommonByteLists; +import org.prism.Nodes.*; +import org.prism.ParsingOptions; +import org.prism.Prism; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static org.jruby.api.Convert.asSymbol; +import static org.jruby.lexer.LexingCommon.DOLLAR_UNDERSCORE; +import static org.jruby.parser.ParserType.EVAL; + +public class ParserPrismWasm extends ParserPrismBase { + public ParserPrismWasm(Ruby runtime) { + super(runtime); + } + + protected byte[] parse(byte[] source, int sourceLength, byte[] metadata) { + try (Prism prism = new Prism()) { + return prism.serialize(metadata, source, sourceLength); + } + } +} From 2408aa84d7dd273085ce9f374c666600bd911546 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Sun, 25 Jan 2026 17:14:55 -0600 Subject: [PATCH 08/21] Document some metadata setup --- .../org/jruby/prism/parser/ParserPrismBase.java | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java index 58eaf8c..56f8f3a 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java @@ -250,12 +250,17 @@ private void appendUnsignedInt(ByteList buf, int value) { buf.append(value >>> 24); } - private byte[] encodeEvalScopes(ByteList buf, StaticScope scope) { + private void encodeEvalScopes(ByteList buf, StaticScope scope) { int startIndex = buf.realSize(); + + // append uint 0 to reserve the space appendUnsignedInt(buf, 0); + + // write the scopes to the buffer int count = encodeEvalScopesInner(buf, scope, 1); + + // overwrite int 0 with scope count writeUnsignedInt(buf, startIndex, count); - return buf.bytes(); } private int encodeEvalScopesInner(ByteList buf, StaticScope scope, int count) { @@ -265,8 +270,13 @@ private int encodeEvalScopesInner(ByteList buf, StaticScope scope, int count) { // once more for method scope String names[] = scope.getVariables(); + + // number of variables appendUnsignedInt(buf, names.length); + + // forwarding flags buf.append(0); + for (String name : names) { // Get the bytes "raw" (which we use ISO8859_1 for) as this is how we record these in StaticScope. byte[] bytes = name.getBytes(ISO8859_1Encoding.INSTANCE.getCharset()); From 0d986cceec25a1e1b4c05c0edf7ec4553f339376 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Sun, 25 Jan 2026 17:15:12 -0600 Subject: [PATCH 09/21] Bump up to v4.0 --- src/main/java/org/jruby/prism/parser/ParserPrismBase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java index 56f8f3a..17ae433 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java @@ -212,7 +212,7 @@ private byte[] generateMetadata(String fileName, int lineNumber, Encoding encodi metadata.append(flags); // version - metadata.append(ParsingOptions.SyntaxVersion.V3_4.getValue()); + metadata.append(ParsingOptions.SyntaxVersion.V4_0.getValue()); // Do not lock encoding metadata.append(0); From b09461686d7588865d019607139574b5d956f73e Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Sun, 25 Jan 2026 17:15:30 -0600 Subject: [PATCH 10/21] Clean up unused imports The native and wasm versions were split off into separate classes, so most of these imports are only needed in the base class now. --- .../jruby/prism/parser/ParserPrismNative.java | 36 ------------------- 1 file changed, 36 deletions(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismNative.java b/src/main/java/org/jruby/prism/parser/ParserPrismNative.java index 3404133..57bfa6c 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismNative.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismNative.java @@ -1,43 +1,7 @@ package org.jruby.prism.parser; -import org.jcodings.Encoding; -import org.jcodings.specific.ISO8859_1Encoding; -import org.jruby.ParseResult; import org.jruby.Ruby; -import org.jruby.RubyArray; -import org.jruby.RubyIO; -import org.jruby.RubyInstanceConfig; -import org.jruby.RubySymbol; -import org.jruby.ext.coverage.CoverageData; import org.jruby.management.ParserStats; -import org.jruby.parser.Parser; -import org.jruby.parser.ParserManager; -import org.jruby.parser.ParserType; -import org.jruby.parser.StaticScope; -import org.jruby.runtime.DynamicScope; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.load.LoadServiceResourceInputStream; -import org.jruby.util.ByteList; -import org.jruby.util.CommonByteLists; -import org.jruby.util.io.ChannelHelper; -import org.prism.Nodes; -import org.prism.Nodes.*; -import org.prism.ParsingOptions; -import org.prism.Prism; - -import java.io.ByteArrayInputStream; -import java.io.DataInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import static org.jruby.api.Convert.asSymbol; -import static org.jruby.lexer.LexingCommon.DOLLAR_UNDERSCORE; -import static org.jruby.parser.ParserType.EVAL; -import static org.jruby.parser.ParserType.MAIN; public class ParserPrismNative extends ParserPrismBase { private final ParserBindingPrism prismLibrary; From cc7e780109ef578f02769c9749e889d32048ec4d Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Sun, 25 Jan 2026 17:16:05 -0600 Subject: [PATCH 11/21] Re-use shared WASM Prism instance The parser should be stateless and a new machine is constructed for each call, so we should be able to reuse the same Prism instance across parses. --- src/main/java/org/jruby/prism/parser/ParserPrismWasm.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java index 92ef1a5..c44b7e4 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java @@ -24,13 +24,13 @@ import static org.jruby.parser.ParserType.EVAL; public class ParserPrismWasm extends ParserPrismBase { + private static final Prism prism = new Prism(); + public ParserPrismWasm(Ruby runtime) { super(runtime); } protected byte[] parse(byte[] source, int sourceLength, byte[] metadata) { - try (Prism prism = new Prism()) { - return prism.serialize(metadata, source, sourceLength); - } + return prism.serialize(metadata, source, sourceLength); } } From 56af28cf7f628032869ffe5b849e14f29c39abf2 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 26 Jan 2026 14:12:33 -0600 Subject: [PATCH 12/21] Use ParsingOptions utility method for options --- .../jruby/prism/parser/ParserPrismBase.java | 108 +++++++++--------- 1 file changed, 53 insertions(+), 55 deletions(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java index 17ae433..e4e28b5 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java @@ -37,7 +37,9 @@ import java.io.InputStream; import java.util.ArrayList; import java.util.Arrays; +import java.util.EnumSet; import java.util.List; +import java.util.stream.IntStream; import static org.jruby.api.Convert.asSymbol; import static org.jruby.lexer.LexingCommon.DOLLAR_UNDERSCORE; @@ -57,7 +59,7 @@ public ParserPrismBase(Ruby runtime) { public ParseResult parse(String fileName, int lineNumber, ByteList content, DynamicScope existingScope, ParserType type) { int sourceLength = content.realSize(); byte[] source = content.begin() == 0 ? content.unsafeBytes() : content.bytes(); - byte[] metadata = generateMetadata(fileName, lineNumber, content.getEncoding(), existingScope, type); + byte[] metadata = generateMetadata(fileName, lineNumber, content.getEncoding(), existingScope); byte[] serialized = parse(source, sourceLength, metadata); return parseInternal(fileName, existingScope, source, serialized, type); } @@ -152,7 +154,7 @@ private void populateScriptData(byte[] source, Encoding encoding, RubyArray line protected ParseResult parse(String fileName, int lineNumber, InputStream in, Encoding encoding, DynamicScope existingScope, ParserType type) { byte[] source = getSourceAsBytes(fileName, in); - byte[] metadata = generateMetadata(fileName, lineNumber, encoding, existingScope, type); + byte[] metadata = generateMetadata(fileName, lineNumber, encoding, existingScope); byte[] serialized = parse(source, source.length, metadata); return parseInternal(fileName, existingScope, source, serialized, type); } @@ -179,61 +181,57 @@ private byte[] loadFully(String fileName, InputStream in) { } // lineNumber (0-indexed) - private byte[] generateMetadata(String fileName, int lineNumber, Encoding encoding, DynamicScope scope, ParserType type) { - ByteList metadata = new ByteList(); - - // Filepath - byte[] name = fileName.getBytes(); - appendUnsignedInt(metadata, name.length); - metadata.append(name); - - // FIXME: I believe line number can be negative? - // Line Number (1-indexed) - appendUnsignedInt(metadata, lineNumber + 1); - - // Encoding - name = encoding.getName(); - appendUnsignedInt(metadata, name.length); - metadata.append(name); - - // frozen string literal - Boolean frozen = runtime.getInstanceConfig().isFrozenStringLiteral(); - metadata.append(frozen != null && frozen ? 1 : 0); - - // command-line flags - RubyInstanceConfig config = runtime.getInstanceConfig(); - byte flags = 0; - if (config.isSplit()) flags |= 1; // -a - if (config.isInlineScript()) flags |= 2; // -e - if (config.isProcessLineEnds()) flags |= 4; // -l - //if (config.isAssumeLoop()) flags |= 8; // -n - //if (config.isAssumePrinting()) flags |= 16; // -p - if (config.isXFlag()) flags |= 32; // -x - metadata.append(flags); - - // version - metadata.append(ParsingOptions.SyntaxVersion.V4_0.getValue()); - - // Do not lock encoding - metadata.append(0); - - // main script - metadata.append(1); - - // partial script - metadata.append(0); - - // freeze - metadata.append(0); - - // Eval scopes (or none for normal parses) - if (type == EVAL) { - encodeEvalScopes(metadata, scope.getStaticScope()); - } else { - appendUnsignedInt(metadata, 0); + private byte[] generateMetadata(String fileName, int lineNumber, Encoding encoding, DynamicScope scope) { + return ParsingOptions.serialize( + fileName.getBytes(), + lineNumber + 1, + encoding.getName(), + (runtime.getInstanceConfig().isFrozenStringLiteral() instanceof Boolean bool && bool), + commandLineFromConfig(runtime.getInstanceConfig()), + ParsingOptions.SyntaxVersion.V4_0, + false, + true, + false, + evalScopes(scope)); + } + + private ParsingOptions.Scope[] evalScopes(DynamicScope scope) { + if (scope == null) return new ParsingOptions.Scope[0]; + + var scopes = new ArrayList(); + + evalScopesRecursive(scope.getStaticScope(), scopes); + + return scopes.toArray(ParsingOptions.Scope[]::new); + } + + private void evalScopesRecursive(StaticScope scope, ArrayList scopes) { + if (scope.getEnclosingScope() != null && scope.isBlockScope()) { + evalScopesRecursive(scope.getEnclosingScope(), scopes); } - return metadata.bytes(); // FIXME: extra arraycopy + scopes.add(new ParsingOptions.Scope( + Arrays + .stream(scope.getVariables()) + .map(String::getBytes) + .toArray(byte[][]::new), + IntStream + .range(0, scope.getVariables().length) + .mapToObj((i) -> ParsingOptions.Forwarding.NONE) + .toArray(ParsingOptions.Forwarding[]::new))); + } + + private EnumSet commandLineFromConfig(RubyInstanceConfig config) { + var list = new ArrayList(); + + if (config.isSplit()) list.add(ParsingOptions.CommandLine.A); // -a + if (config.isInlineScript()) list.add(ParsingOptions.CommandLine.E); // -e + if (config.isProcessLineEnds()) list.add(ParsingOptions.CommandLine.L); // -l + if (config.isAssumeLoop()) list.add(ParsingOptions.CommandLine.N); // -n + if (config.isAssumePrinting()) list.add(ParsingOptions.CommandLine.P); // -p + if (config.isXFlag()) list.add(ParsingOptions.CommandLine.X); // -x + + return EnumSet.copyOf(list); } private void writeUnsignedInt(ByteList buf, int index, int value) { From 976b8b29de06ea7e1776bec15959dcbc28d9ac16 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 26 Jan 2026 14:13:13 -0600 Subject: [PATCH 13/21] Clean up wasm wrapper and use pure-WASM for now --- .../jruby/prism/parser/ParserPrismWasm.java | 25 +++---------------- 1 file changed, 3 insertions(+), 22 deletions(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java index c44b7e4..4ce643d 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java @@ -1,30 +1,11 @@ package org.jruby.prism.parser; -import org.jcodings.Encoding; -import org.jcodings.specific.ISO8859_1Encoding; -import org.jruby.*; -import org.jruby.parser.Parser; -import org.jruby.parser.ParserType; -import org.jruby.parser.StaticScope; -import org.jruby.runtime.DynamicScope; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.CommonByteLists; -import org.prism.Nodes.*; -import org.prism.ParsingOptions; +import org.jruby.Ruby; import org.prism.Prism; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import static org.jruby.api.Convert.asSymbol; -import static org.jruby.lexer.LexingCommon.DOLLAR_UNDERSCORE; -import static org.jruby.parser.ParserType.EVAL; +import org.prism.PrismWASM; public class ParserPrismWasm extends ParserPrismBase { - private static final Prism prism = new Prism(); + private static final Prism prism = new PrismWASM(); public ParserPrismWasm(Ruby runtime) { super(runtime); From 3f21dfd19188fe7452fccbc2df283da75ebe3428 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 3 Feb 2026 12:58:18 -0600 Subject: [PATCH 14/21] Can't make an enum set out of empty collection --- src/main/java/org/jruby/prism/parser/ParserPrismBase.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java index e4e28b5..c6816e0 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java @@ -231,7 +231,7 @@ private EnumSet commandLineFromConfig(RubyInstanceCo if (config.isAssumePrinting()) list.add(ParsingOptions.CommandLine.P); // -p if (config.isXFlag()) list.add(ParsingOptions.CommandLine.X); // -x - return EnumSet.copyOf(list); + return list.isEmpty() ? EnumSet.noneOf(ParsingOptions.CommandLine.class) : EnumSet.copyOf(list); } private void writeUnsignedInt(ByteList buf, int index, int value) { From bc1a9b5aa70e648cbc1febf5c1345cb689465865 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 3 Feb 2026 13:55:56 -0600 Subject: [PATCH 15/21] Update parser to Java 21 This will primarily be used with JRuby 10+, which requires Java 21. --- pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 7a41fc0..6fb5007 100644 --- a/pom.xml +++ b/pom.xml @@ -14,8 +14,8 @@ UTF-8 1.2.1 5.12.1 - 17 - 17 + 21 + 21 From 7d2598f57c37a55107c621736579a4af5873aa98 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Tue, 3 Feb 2026 13:56:19 -0600 Subject: [PATCH 16/21] Synchronize access to the Prism instance WASM is inherently single-threaded, so we cannot allow multiple threads to be parsing with a single chicory-prism instance at the same time. For now, we synchronize that access. A pool of instances or a soft thread-local could be used in the future if that becomes a bottleneck. --- src/main/java/org/jruby/prism/parser/ParserPrismWasm.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java index 4ce643d..de5d983 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java @@ -2,16 +2,15 @@ import org.jruby.Ruby; import org.prism.Prism; -import org.prism.PrismWASM; public class ParserPrismWasm extends ParserPrismBase { - private static final Prism prism = new PrismWASM(); + private final Prism prism = new Prism(); public ParserPrismWasm(Ruby runtime) { super(runtime); } - protected byte[] parse(byte[] source, int sourceLength, byte[] metadata) { + protected synchronized byte[] parse(byte[] source, int sourceLength, byte[] metadata) { return prism.serialize(metadata, source, sourceLength); } } From 6a51501e76790940e214d88a4dde51fd6d4ef2a1 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Fri, 20 Feb 2026 17:34:06 -0600 Subject: [PATCH 17/21] Update packages --- .../jruby/prism/builder/IRBuilderPrism.java | 4 +-- .../builder/LazyMethodDefinitionPrism.java | 18 ++++++------- .../prism/parser/CoverageLineVisitor.java | 4 +-- .../org/jruby/prism/parser/LoaderPrism.java | 6 ++--- .../jruby/prism/parser/ParseResultPrism.java | 2 +- .../jruby/prism/parser/ParserPrismBase.java | 26 +++++++++---------- .../jruby/prism/parser/ParserPrismWasm.java | 2 +- 7 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java b/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java index 2dc9172..1097cba 100644 --- a/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java +++ b/src/main/java/org/jruby/prism/builder/IRBuilderPrism.java @@ -62,8 +62,8 @@ import org.jruby.util.RegexpOptions; import org.jruby.util.StringSupport; import org.jruby.util.cli.Options; -import org.prism.Nodes; -import org.prism.Nodes.*; +import org.ruby_lang.prism.Nodes; +import org.ruby_lang.prism.Nodes.*; import org.jruby.prism.parser.ParseResultPrism; import java.math.BigInteger; diff --git a/src/main/java/org/jruby/prism/builder/LazyMethodDefinitionPrism.java b/src/main/java/org/jruby/prism/builder/LazyMethodDefinitionPrism.java index 4ef6cca..cf814e3 100644 --- a/src/main/java/org/jruby/prism/builder/LazyMethodDefinitionPrism.java +++ b/src/main/java/org/jruby/prism/builder/LazyMethodDefinitionPrism.java @@ -6,15 +6,15 @@ import org.jruby.ir.builder.IRBuilder; import org.jruby.ir.builder.LazyMethodDefinition; import org.jruby.prism.builder.IRBuilderPrism; -import org.prism.AbstractNodeVisitor; -import org.prism.Nodes; -import org.prism.Nodes.ConstantPathNode; -import org.prism.Nodes.DefNode; -import org.prism.Nodes.InstanceVariableReadNode; -import org.prism.Nodes.InstanceVariableWriteNode; -import org.prism.Nodes.Node; -import org.prism.Nodes.RescueNode; -import org.prism.Nodes.WhenNode; +import org.ruby_lang.prism.AbstractNodeVisitor; +import org.ruby_lang.prism.Nodes; +import org.ruby_lang.prism.Nodes.ConstantPathNode; +import org.ruby_lang.prism.Nodes.DefNode; +import org.ruby_lang.prism.Nodes.InstanceVariableReadNode; +import org.ruby_lang.prism.Nodes.InstanceVariableWriteNode; +import org.ruby_lang.prism.Nodes.Node; +import org.ruby_lang.prism.Nodes.RescueNode; +import org.ruby_lang.prism.Nodes.WhenNode; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/org/jruby/prism/parser/CoverageLineVisitor.java b/src/main/java/org/jruby/prism/parser/CoverageLineVisitor.java index e3862df..48eea10 100644 --- a/src/main/java/org/jruby/prism/parser/CoverageLineVisitor.java +++ b/src/main/java/org/jruby/prism/parser/CoverageLineVisitor.java @@ -1,7 +1,7 @@ package org.jruby.prism.parser; -import org.prism.AbstractNodeVisitor; -import org.prism.Nodes; +import org.ruby_lang.prism.AbstractNodeVisitor; +import org.ruby_lang.prism.Nodes; public class CoverageLineVisitor extends AbstractNodeVisitor { diff --git a/src/main/java/org/jruby/prism/parser/LoaderPrism.java b/src/main/java/org/jruby/prism/parser/LoaderPrism.java index 1843f47..f8f3027 100644 --- a/src/main/java/org/jruby/prism/parser/LoaderPrism.java +++ b/src/main/java/org/jruby/prism/parser/LoaderPrism.java @@ -3,9 +3,9 @@ import org.jcodings.Encoding; import org.jruby.Ruby; import org.jruby.util.ByteList; -import org.prism.Loader; -import org.prism.Nodes; -import org.prism.ParseResult; +import org.ruby_lang.prism.Loader; +import org.ruby_lang.prism.Nodes; +import org.ruby_lang.prism.ParseResult; /** * Extends Loader to override some things which are not generated directly diff --git a/src/main/java/org/jruby/prism/parser/ParseResultPrism.java b/src/main/java/org/jruby/prism/parser/ParseResultPrism.java index e8f6d4a..234b8b5 100644 --- a/src/main/java/org/jruby/prism/parser/ParseResultPrism.java +++ b/src/main/java/org/jruby/prism/parser/ParseResultPrism.java @@ -5,7 +5,7 @@ import org.jruby.prism.builder.IRBuilderPrism; import org.jruby.parser.StaticScope; import org.jruby.runtime.DynamicScope; -import org.prism.Nodes; +import org.ruby_lang.prism.Nodes; public class ParseResultPrism implements ParseResult { final Encoding encoding; diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java index c6816e0..a082d2d 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismBase.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismBase.java @@ -20,16 +20,16 @@ import org.jruby.util.ByteList; import org.jruby.util.CommonByteLists; import org.jruby.util.io.ChannelHelper; -import org.prism.Nodes.ArgumentsNode; -import org.prism.Nodes.CallNode; -import org.prism.Nodes.CallNodeFlags; -import org.prism.Nodes.GlobalVariableReadNode; -import org.prism.Nodes.GlobalVariableWriteNode; -import org.prism.Nodes.Node; -import org.prism.Nodes.ProgramNode; -import org.prism.Nodes.StatementsNode; -import org.prism.Nodes.WhileNode; -import org.prism.ParsingOptions; +import org.ruby_lang.prism.Nodes.ArgumentsNode; +import org.ruby_lang.prism.Nodes.CallNode; +import org.ruby_lang.prism.Nodes.CallNodeFlags; +import org.ruby_lang.prism.Nodes.GlobalVariableReadNode; +import org.ruby_lang.prism.Nodes.GlobalVariableWriteNode; +import org.ruby_lang.prism.Nodes.Node; +import org.ruby_lang.prism.Nodes.ProgramNode; +import org.ruby_lang.prism.Nodes.StatementsNode; +import org.ruby_lang.prism.Nodes.WhileNode; +import org.ruby_lang.prism.ParsingOptions; import java.io.ByteArrayInputStream; import java.io.DataInputStream; @@ -69,7 +69,7 @@ private ParseResult parseInternal(String fileName, DynamicScope blockScope, byte if (parserTiming) time = System.nanoTime(); LoaderPrism loader = new LoaderPrism(runtime, serialized, source); - org.prism.ParseResult res = loader.load(); + org.ruby_lang.prism.ParseResult res = loader.load(); Encoding encoding = loader.getEncoding(); if (parserTiming) { @@ -81,8 +81,8 @@ private ParseResult parseInternal(String fileName, DynamicScope blockScope, byte } if (res.warnings != null) { - for (org.prism.ParseResult.Warning warning: res.warnings) { - if (warning.level != org.prism.ParseResult.WarningLevel.WARNING_VERBOSE || runtime.isVerbose()) { + for (org.ruby_lang.prism.ParseResult.Warning warning: res.warnings) { + if (warning.level != org.ruby_lang.prism.ParseResult.WarningLevel.WARNING_VERBOSE || runtime.isVerbose()) { runtime.getWarnings().warn(fileName, res.source.line(warning.location.startOffset), warning.message); } } diff --git a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java index de5d983..01c995e 100644 --- a/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java +++ b/src/main/java/org/jruby/prism/parser/ParserPrismWasm.java @@ -1,7 +1,7 @@ package org.jruby.prism.parser; import org.jruby.Ruby; -import org.prism.Prism; +import org.jruby.parser.prism.wasm.Prism; public class ParserPrismWasm extends ParserPrismBase { private final Prism prism = new Prism(); From 3bc582eb47f11fc57c73a29d8e8a0c2f4b34cbc1 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 23 Feb 2026 15:58:05 -0600 Subject: [PATCH 18/21] Add sonatype Maven Central deploy plugin --- pom.xml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/pom.xml b/pom.xml index 6fb5007..0693395 100644 --- a/pom.xml +++ b/pom.xml @@ -116,6 +116,15 @@ + + org.sonatype.central + central-publishing-maven-plugin + 0.7.0 + true + + central + + From 22ae2e5fd0a94c25f20a16862b6126ba8b67932d Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 23 Feb 2026 15:59:45 -0600 Subject: [PATCH 19/21] Add basic CI job to build and test --- .github/workflows/ci.yml | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..f61c1cb --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,23 @@ +name: Java CI with Maven + +on: + push: + branches: [ "main" ] + pull_request: + branches: [ "main" ] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + - name: Set up JDK 21 + uses: actions/setup-java@v4 + with: + java-version: '21' + distribution: 'temurin' + cache: maven + - name: Build with Maven + run: mvn -ntp package --file pom.xml From 6b0546ad83b064ba15c2d460545328cf6c4e8552 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 23 Feb 2026 16:03:16 -0600 Subject: [PATCH 20/21] Add sonatype snapshots repo --- pom.xml | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/pom.xml b/pom.xml index 0693395..1d5e3a5 100644 --- a/pom.xml +++ b/pom.xml @@ -50,6 +50,19 @@ + + + + false + + + true + + sonatype + https://central.sonatype.com/repository/maven-snapshots/ + + + From 70a8b5c9363c181f18aeb0846909eb3720de6694 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Mon, 23 Feb 2026 16:14:11 -0600 Subject: [PATCH 21/21] Remove old ossrh parent --- pom.xml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/pom.xml b/pom.xml index 1d5e3a5..83218ce 100644 --- a/pom.xml +++ b/pom.xml @@ -18,12 +18,6 @@ 21 - - org.sonatype.oss - oss-parent - 9 - - GitHub https://github.com/jruby/jruby-prism/issues