#[allow(clippy::too_many_arguments)]
fn prettyprint_body(
buffer: &mut SerializationBuffer,
type_id: u8,
pool: usize,
output: &mut String,
prefix: &mut String,
start_offset: usize,
end_offset: usize,
newlines: &[usize],
children: &mut std::vec::IntoIter<Option<PrismRecord>>,
) {
match type_id {
1 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ AliasGlobalVariableNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- new_name:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- old_name:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
2 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ AliasMethodNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- new_name:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- old_name:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
3 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ AlternationPatternNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- left:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- right:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
4 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ AndNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- left:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- right:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
5 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ArgumentsNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ArgumentsNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" contains_forwarding");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" contains_keywords");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" contains_keyword_splat");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" contains_splat");
found = true;
}
if flags & (1 << 6) != 0 {
if found {
output.push(',');
}
output.push_str(" contains_multiple_splats");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- arguments:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
}
6 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ArrayNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ArrayNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" contains_splat");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- elements:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
7 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ArrayPatternNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- constant:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- requireds:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rest:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- posts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
8 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ AssocNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- key:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
9 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ AssocSplatNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
10 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BackReferenceReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
11 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BeginNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- begin_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rescue_clause:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- else_clause:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- ensure_clause:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
12 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BlockArgumentNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- expression:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
13 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BlockLocalVariableNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
14 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BlockNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(" [");
for index in 0..count {
if index != 0 {
output.push_str(", ");
}
output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
}
output.push_str("]\n");
}
output.push_str(prefix);
output.push_str("+-- parameters:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- body:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
15 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BlockParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
match buffer.read_optional_constant(pool) {
Some(name) => output.push_str(&format!(" :{name}\n")),
None => output.push_str(" nil\n"),
}
output.push_str(prefix);
output.push_str("+-- name_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
16 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BlockParametersNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- parameters:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
17 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ BreakNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
18 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CallAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- message_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- read_name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- write_name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
19 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CallNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- message_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- equal_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
20 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CallOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- message_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- read_name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- write_name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
21 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CallOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- message_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- read_name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- write_name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
22 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CallTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- message_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
23 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CapturePatternNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- target:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
24 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CaseMatchNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- predicate:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- conditions:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- else_clause:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- case_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
25 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ CaseNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- predicate:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- conditions:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- else_clause:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- case_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
26 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ClassNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(" [");
for index in 0..count {
if index != 0 {
output.push_str(", ");
}
output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
}
output.push_str("]\n");
}
output.push_str(prefix);
output.push_str("+-- class_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- constant_path:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- inheritance_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- superclass:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- body:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
27 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ClassVariableAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
28 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ClassVariableOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
29 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ClassVariableOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
30 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ClassVariableReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
31 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ClassVariableTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
32 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ClassVariableWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
33 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
34 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
35 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
36 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantPathAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- target:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
37 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantPathNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- parent:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- name:");
match buffer.read_optional_constant(pool) {
Some(name) => output.push_str(&format!(" :{name}\n")),
None => output.push_str(" nil\n"),
}
output.push_str(prefix);
output.push_str("+-- delimiter_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
38 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantPathOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- target:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
39 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantPathOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- target:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
40 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantPathTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- parent:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- name:");
match buffer.read_optional_constant(pool) {
Some(name) => output.push_str(&format!(" :{name}\n")),
None => output.push_str(" nil\n"),
}
output.push_str(prefix);
output.push_str("+-- delimiter_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
41 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantPathWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- target:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
42 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
43 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
44 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ConstantWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
45 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ DefNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- parameters:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- body:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(" [");
for index in 0..count {
if index != 0 {
output.push_str(", ");
}
output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
}
output.push_str("]\n");
}
output.push_str(prefix);
output.push_str("+-- def_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- lparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- rparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- equal_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
46 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ DefinedNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- lparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
47 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ElseNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- else_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
48 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ EmbeddedStatementsNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
49 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ EmbeddedVariableNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- variable:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
50 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ EnsureNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ensure_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
51 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ErrorRecoveryNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- unexpected:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
52 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ FalseNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
53 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ FindPatternNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- constant:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- left:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- requireds:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- right:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
54 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ FlipFlopNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- RangeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" exclude_end");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- left:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- right:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
55 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ FloatNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- value:");
output.push_str(&format!(" {:.6}\n", buffer.read_double()));
}
56 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ForNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- index:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- collection:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- for_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- in_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- do_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
57 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ForwardingArgumentsNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
58 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ForwardingParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
59 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ForwardingSuperNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
60 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ GlobalVariableAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
61 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ GlobalVariableOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
62 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ GlobalVariableOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
63 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ GlobalVariableReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
64 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ GlobalVariableTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
65 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ GlobalVariableWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
66 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ HashNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- elements:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
67 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ HashPatternNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- constant:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- elements:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rest:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
68 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ IfNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- if_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- predicate:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- then_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- subsequent:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
69 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ImaginaryNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- numeric:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
70 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ImplicitNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
71 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ImplicitRestNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
72 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- pattern:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- in_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- then_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
73 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ IndexAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
74 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ IndexOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
75 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ IndexOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- call_operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
76 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ IndexTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- CallNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" safe_navigation");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" variable_call");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" attribute_write");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_visibility");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- receiver:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
77 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InstanceVariableAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
78 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InstanceVariableOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
79 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InstanceVariableOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
80 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InstanceVariableReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
81 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InstanceVariableTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
82 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InstanceVariableWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
83 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ IntegerNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- IntegerBaseFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" binary");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" decimal");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" octal");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" hexadecimal");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- value:");
output.push_str(&format!(" {}\n", buffer.read_integer_string()));
}
84 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InterpolatedMatchLastLineNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- RegularExpressionFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_case");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" extended");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" multi_line");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" once");
found = true;
}
if flags & (1 << 6) != 0 {
if found {
output.push(',');
}
output.push_str(" euc_jp");
found = true;
}
if flags & (1 << 7) != 0 {
if found {
output.push(',');
}
output.push_str(" ascii_8bit");
found = true;
}
if flags & (1 << 8) != 0 {
if found {
output.push(',');
}
output.push_str(" windows_31j");
found = true;
}
if flags & (1 << 9) != 0 {
if found {
output.push(',');
}
output.push_str(" utf_8");
found = true;
}
if flags & (1 << 10) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 11) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if flags & (1 << 12) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_us_ascii_encoding");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- parts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
85 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InterpolatedRegularExpressionNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- RegularExpressionFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_case");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" extended");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" multi_line");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" once");
found = true;
}
if flags & (1 << 6) != 0 {
if found {
output.push(',');
}
output.push_str(" euc_jp");
found = true;
}
if flags & (1 << 7) != 0 {
if found {
output.push(',');
}
output.push_str(" ascii_8bit");
found = true;
}
if flags & (1 << 8) != 0 {
if found {
output.push(',');
}
output.push_str(" windows_31j");
found = true;
}
if flags & (1 << 9) != 0 {
if found {
output.push(',');
}
output.push_str(" utf_8");
found = true;
}
if flags & (1 << 10) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 11) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if flags & (1 << 12) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_us_ascii_encoding");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- parts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
86 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InterpolatedStringNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- InterpolatedStringNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" frozen");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" mutable");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- parts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
87 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InterpolatedSymbolNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- parts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
88 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ InterpolatedXStringNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- parts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
89 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ItLocalVariableReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
90 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ItParametersNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
91 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ KeywordHashNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- KeywordHashNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" symbol_keys");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- elements:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
}
92 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ KeywordRestParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
match buffer.read_optional_constant(pool) {
Some(name) => output.push_str(&format!(" :{name}\n")),
None => output.push_str(" nil\n"),
}
output.push_str(prefix);
output.push_str("+-- name_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
93 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ LambdaNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(" [");
for index in 0..count {
if index != 0 {
output.push_str(", ");
}
output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
}
output.push_str("]\n");
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- parameters:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- body:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
94 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ LocalVariableAndWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- depth:");
output.push_str(&format!(" {}\n", buffer.read_var_int()));
}
95 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ LocalVariableOperatorWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- binary_operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- binary_operator:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- depth:");
output.push_str(&format!(" {}\n", buffer.read_var_int()));
}
96 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ LocalVariableOrWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- depth:");
output.push_str(&format!(" {}\n", buffer.read_var_int()));
}
97 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ LocalVariableReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- depth:");
output.push_str(&format!(" {}\n", buffer.read_var_int()));
}
98 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ LocalVariableTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- depth:");
output.push_str(&format!(" {}\n", buffer.read_var_int()));
}
99 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ LocalVariableWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- depth:");
output.push_str(&format!(" {}\n", buffer.read_var_int()));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
100 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ MatchLastLineNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- RegularExpressionFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_case");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" extended");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" multi_line");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" once");
found = true;
}
if flags & (1 << 6) != 0 {
if found {
output.push(',');
}
output.push_str(" euc_jp");
found = true;
}
if flags & (1 << 7) != 0 {
if found {
output.push(',');
}
output.push_str(" ascii_8bit");
found = true;
}
if flags & (1 << 8) != 0 {
if found {
output.push(',');
}
output.push_str(" windows_31j");
found = true;
}
if flags & (1 << 9) != 0 {
if found {
output.push(',');
}
output.push_str(" utf_8");
found = true;
}
if flags & (1 << 10) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 11) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if flags & (1 << 12) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_us_ascii_encoding");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- content_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- unescaped:");
{
let value = buffer.read_string_field(0);
output.push_str(&format!(" \"{}\"\n", crate::prism::buffer::escape_ruby(value.as_bytes())));
}
}
101 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ MatchPredicateNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- pattern:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
102 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ MatchRequiredNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- pattern:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
103 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ MatchWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- call:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- targets:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
}
104 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ModuleNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(" [");
for index in 0..count {
if index != 0 {
output.push_str(", ");
}
output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
}
output.push_str("]\n");
}
output.push_str(prefix);
output.push_str("+-- module_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- constant_path:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- body:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
105 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ MultiTargetNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- lefts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rest:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rights:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- lparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- rparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
106 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ MultiWriteNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- lefts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rest:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rights:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- lparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- rparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
107 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ NextNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
108 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ NilNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
109 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ NoBlockParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
110 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ NoKeywordsParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
111 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ NumberedParametersNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- maximum:");
output.push_str(&format!(" {}\n", buffer.read_byte()));
}
112 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ NumberedReferenceReadNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- number:");
output.push_str(&format!(" {}\n", buffer.read_var_int()));
}
113 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ OptionalKeywordParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
114 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ OptionalParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- value:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
115 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ OrNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- left:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- right:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
116 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ParametersNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- requireds:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- optionals:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rest:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- posts:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keywords:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_rest:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
117 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ParenthesesNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParenthesesNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" multiple_statements");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- body:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
118 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ PinnedExpressionNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- expression:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- lparen_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- rparen_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
119 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ PinnedVariableNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- variable:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
120 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ PostExecutionNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
121 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ PreExecutionNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
122 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ProgramNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(" [");
for index in 0..count {
if index != 0 {
output.push_str(", ");
}
output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
}
output.push_str("]\n");
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
123 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RangeNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- RangeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" exclude_end");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- left:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- right:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
124 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RationalNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- IntegerBaseFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" binary");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" decimal");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" octal");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" hexadecimal");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- numerator:");
output.push_str(&format!(" {}\n", buffer.read_integer_string()));
output.push_str(prefix);
output.push_str("+-- denominator:");
output.push_str(&format!(" {}\n", buffer.read_integer_string()));
}
125 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RedoNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
126 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RegularExpressionNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- RegularExpressionFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" ignore_case");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" extended");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" multi_line");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" once");
found = true;
}
if flags & (1 << 6) != 0 {
if found {
output.push(',');
}
output.push_str(" euc_jp");
found = true;
}
if flags & (1 << 7) != 0 {
if found {
output.push(',');
}
output.push_str(" ascii_8bit");
found = true;
}
if flags & (1 << 8) != 0 {
if found {
output.push(',');
}
output.push_str(" windows_31j");
found = true;
}
if flags & (1 << 9) != 0 {
if found {
output.push(',');
}
output.push_str(" utf_8");
found = true;
}
if flags & (1 << 10) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 11) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if flags & (1 << 12) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_us_ascii_encoding");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- content_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- unescaped:");
{
let value = buffer.read_string_field(0);
output.push_str(&format!(" \"{}\"\n", crate::prism::buffer::escape_ruby(value.as_bytes())));
}
}
127 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RequiredKeywordParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
output.push_str(prefix);
output.push_str("+-- name_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
128 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RequiredParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
}
129 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RescueModifierNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- expression:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- rescue_expression:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
130 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RescueNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- exceptions:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- reference:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- then_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- subsequent:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
131 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RestParameterNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ParameterFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" repeated_parameter");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- name:");
match buffer.read_optional_constant(pool) {
Some(name) => output.push_str(&format!(" :{name}\n")),
None => output.push_str(" nil\n"),
}
output.push_str(prefix);
output.push_str("+-- name_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
132 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ RetryNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
133 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ReturnNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
134 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SelfNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
135 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ ShareableConstantNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- ShareableConstantNodeFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" literal");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" experimental_everything");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" experimental_copy");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- write:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
136 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SingletonClassNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- locals:");
{
let count = buffer.read_var_int();
output.push_str(" [");
for index in 0..count {
if index != 0 {
output.push_str(", ");
}
output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
}
output.push_str("]\n");
}
output.push_str(prefix);
output.push_str("+-- class_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- expression:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- body:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
137 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SourceEncodingNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
138 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SourceFileNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- StringFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" frozen");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" mutable");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- filepath:");
{
let value = buffer.read_string_field(0);
output.push_str(&format!(" \"{}\"\n", crate::prism::buffer::escape_ruby(value.as_bytes())));
}
}
139 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SourceLineNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
140 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SplatNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- operator_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- expression:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
141 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ StatementsNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- body:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
}
142 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ StringNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- StringFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" frozen");
found = true;
}
if flags & (1 << 5) != 0 {
if found {
output.push(',');
}
output.push_str(" mutable");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- content_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- unescaped:");
{
let value = buffer.read_string_field(0);
output.push_str(&format!(" \"{}\"\n", crate::prism::buffer::escape_ruby(value.as_bytes())));
}
}
143 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SuperNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- lparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- block:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
144 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ SymbolNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- SymbolFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if flags & (1 << 4) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_us_ascii_encoding");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- content_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- unescaped:");
{
let value = buffer.read_string_field(0);
output.push_str(&format!(" \"{}\"\n", crate::prism::buffer::escape_ruby(value.as_bytes())));
}
}
145 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ TrueNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
}
146 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ UndefNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- names:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
}
147 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ UnlessNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- unless_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- predicate:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- then_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- else_clause:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
148 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ UntilNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- LoopFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" begin_modifier");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- until_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- do_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- predicate:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
149 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ WhenNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- when_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- conditions:");
{
let count = buffer.read_var_int();
output.push_str(&format!(" (length: {count})\n"));
for index in 0..count {
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
output.push_str("+-- ");
prefix.push_str(if index == count - 1 { " " } else { "| " });
if let Some(child) = children.next().flatten() {
prettyprint_record(child, buffer, pool, output, prefix, newlines);
}
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- then_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
150 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ WhileNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- LoopFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" begin_modifier");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- while_keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- do_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- end_keyword_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- predicate:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- statements:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str(" ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
}
151 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ XStringNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- EncodingFlags:");
{
let mut found = false;
if flags & (1 << 2) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_utf8_encoding");
found = true;
}
if flags & (1 << 3) != 0 {
if found {
output.push(',');
}
output.push_str(" forced_binary_encoding");
found = true;
}
if !found {
output.push_str(" nil");
}
output.push('\n');
}
output.push_str(prefix);
output.push_str("+-- opening_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- content_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- closing_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- unescaped:");
{
let value = buffer.read_string_field(0);
output.push_str(&format!(" \"{}\"\n", crate::prism::buffer::escape_ruby(value.as_bytes())));
}
}
152 => {
#[allow(unused_variables)]
let flags = buffer.read_var_int() as u32;
output.push_str(&format!("@ YieldNode (location: {})\n", location_string(start_offset, end_offset, newlines)));
output.push_str(prefix);
output.push_str("+-- keyword_loc:");
{
let (start, length) = buffer.read_location();
output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
));
}
output.push_str(prefix);
output.push_str("+-- lparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
output.push_str(prefix);
output.push_str("+-- arguments:");
match children.next().flatten() {
None => output.push_str(" nil\n"),
Some(child) => {
output.push('\n');
let saved = prefix.len();
prefix.push_str("| ");
let copy = prefix.clone();
output.push_str(©);
prettyprint_record(child, buffer, pool, output, prefix, newlines);
prefix.truncate(saved);
}
}
output.push_str(prefix);
output.push_str("+-- rparen_loc:");
match buffer.read_optional_location() {
None => output.push_str(" nil\n"),
Some((start, length)) => output.push_str(&format!(
" {} = \"{}\"\n",
location_string(start, start + length, newlines),
crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
)),
}
}
_ => {}
}
}