syntax_tree 2.3.1 → 2.5.0

data/lib/syntax_tree/visitor/field_visitor.rb

@@ -0,0 +1,1115 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  class Visitor
+    # This is the parent class of a lot of built-in visitors for Syntax Tree. It
+    # reflects visiting each of the fields on every node in turn. It itself does
+    # not do anything with these fields, it leaves that behavior up to the
+    # subclass to implement.
+    #
+    # In order to properly use this class, you will need to subclass it and
+    # implement #comments, #field, #list, #node, #pairs, and #text. Those are
+    # documented here.
+    #
+    # == comments(node)
+    #
+    # This accepts the node that is being visited and does something depending
+    # on the comments attached to the node.
+    #
+    # == field(name, value)
+    #
+    # This accepts the name of the field being visited as a string (like
+    # "value") and the actual value of that field. The value can be a subclass
+    # of Node or any other type that can be held within the tree.
+    #
+    # == list(name, values)
+    #
+    # This accepts the name of the field being visited as well as a list of
+    # values. This is used, for example, when visiting something like the body
+    # of a Statements node.
+    #
+    # == node(name, node)
+    #
+    # This is the parent serialization method for each node. It is called with
+    # the node itself, as well as the type of the node as a string. The type
+    # is an internally used value that usually resembles the name of the
+    # ripper event that generated the node. The method should yield to the
+    # given block which then calls through to visit each of the fields on the
+    # node.
+    #
+    # == text(name, value)
+    #
+    # This accepts the name of the field being visited as well as a string
+    # value representing the value of the field.
+    #
+    # == pairs(name, values)
+    #
+    # This accepts the name of the field being visited as well as a list of
+    # pairs that represent the value of the field. It is used only in a couple
+    # of circumstances, like when visiting the list of optional parameters
+    # defined on a method.
+    #
+    class FieldVisitor < Visitor
+      attr_reader :q
+
+      def visit_aref(node)
+        node(node, "aref") do
+          field("collection", node.collection)
+          field("index", node.index)
+          comments(node)
+        end
+      end
+
+      def visit_aref_field(node)
+        node(node, "aref_field") do
+          field("collection", node.collection)
+          field("index", node.index)
+          comments(node)
+        end
+      end
+
+      def visit_alias(node)
+        node(node, "alias") do
+          field("left", node.left)
+          field("right", node.right)
+          comments(node)
+        end
+      end
+
+      def visit_arg_block(node)
+        node(node, "arg_block") do
+          field("value", node.value) if node.value
+          comments(node)
+        end
+      end
+
+      def visit_arg_paren(node)
+        node(node, "arg_paren") do
+          field("arguments", node.arguments)
+          comments(node)
+        end
+      end
+
+      def visit_arg_star(node)
+        node(node, "arg_star") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_args(node)
+        node(node, "args") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_args_forward(node)
+        visit_token(node, "args_forward")
+      end
+
+      def visit_array(node)
+        node(node, "array") do
+          field("contents", node.contents)
+          comments(node)
+        end
+      end
+
+      def visit_aryptn(node)
+        node(node, "aryptn") do
+          field("constant", node.constant) if node.constant
+          list("requireds", node.requireds) if node.requireds.any?
+          field("rest", node.rest) if node.rest
+          list("posts", node.posts) if node.posts.any?
+          comments(node)
+        end
+      end
+
+      def visit_assign(node)
+        node(node, "assign") do
+          field("target", node.target)
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_assoc(node)
+        node(node, "assoc") do
+          field("key", node.key)
+          field("value", node.value) if node.value
+          comments(node)
+        end
+      end
+
+      def visit_assoc_splat(node)
+        node(node, "assoc_splat") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_backref(node)
+        visit_token(node, "backref")
+      end
+
+      def visit_backtick(node)
+        visit_token(node, "backtick")
+      end
+
+      def visit_bare_assoc_hash(node)
+        node(node, "bare_assoc_hash") do
+          list("assocs", node.assocs)
+          comments(node)
+        end
+      end
+
+      def visit_BEGIN(node)
+        node(node, "BEGIN") do
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_begin(node)
+        node(node, "begin") do
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
+      def visit_binary(node)
+        node(node, "binary") do
+          field("left", node.left)
+          text("operator", node.operator)
+          field("right", node.right)
+          comments(node)
+        end
+      end
+
+      def visit_blockarg(node)
+        node(node, "blockarg") do
+          field("name", node.name) if node.name
+          comments(node)
+        end
+      end
+
+      def visit_block_var(node)
+        node(node, "block_var") do
+          field("params", node.params)
+          list("locals", node.locals) if node.locals.any?
+          comments(node)
+        end
+      end
+
+      def visit_bodystmt(node)
+        node(node, "bodystmt") do
+          field("statements", node.statements)
+          field("rescue_clause", node.rescue_clause) if node.rescue_clause
+          field("else_clause", node.else_clause) if node.else_clause
+          field("ensure_clause", node.ensure_clause) if node.ensure_clause
+          comments(node)
+        end
+      end
+
+      def visit_brace_block(node)
+        node(node, "brace_block") do
+          field("block_var", node.block_var) if node.block_var
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_break(node)
+        node(node, "break") do
+          field("arguments", node.arguments)
+          comments(node)
+        end
+      end
+
+      def visit_call(node)
+        node(node, "call") do
+          field("receiver", node.receiver)
+          field("operator", node.operator)
+          field("message", node.message)
+          field("arguments", node.arguments) if node.arguments
+          comments(node)
+        end
+      end
+
+      def visit_case(node)
+        node(node, "case") do
+          field("keyword", node.keyword)
+          field("value", node.value) if node.value
+          field("consequent", node.consequent)
+          comments(node)
+        end
+      end
+
+      def visit_CHAR(node)
+        visit_token(node, "CHAR")
+      end
+
+      def visit_class(node)
+        node(node, "class") do
+          field("constant", node.constant)
+          field("superclass", node.superclass) if node.superclass
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
+      def visit_comma(node)
+        node(node, "comma") { field("value", node.value) }
+      end
+
+      def visit_command(node)
+        node(node, "command") do
+          field("message", node.message)
+          field("arguments", node.arguments)
+          comments(node)
+        end
+      end
+
+      def visit_command_call(node)
+        node(node, "command_call") do
+          field("receiver", node.receiver)
+          field("operator", node.operator)
+          field("message", node.message)
+          field("arguments", node.arguments) if node.arguments
+          comments(node)
+        end
+      end
+
+      def visit_comment(node)
+        node(node, "comment") { field("value", node.value) }
+      end
+
+      def visit_const(node)
+        visit_token(node, "const")
+      end
+
+      def visit_const_path_field(node)
+        node(node, "const_path_field") do
+          field("parent", node.parent)
+          field("constant", node.constant)
+          comments(node)
+        end
+      end
+
+      def visit_const_path_ref(node)
+        node(node, "const_path_ref") do
+          field("parent", node.parent)
+          field("constant", node.constant)
+          comments(node)
+        end
+      end
+
+      def visit_const_ref(node)
+        node(node, "const_ref") do
+          field("constant", node.constant)
+          comments(node)
+        end
+      end
+
+      def visit_cvar(node)
+        visit_token(node, "cvar")
+      end
+
+      def visit_def(node)
+        node(node, "def") do
+          field("name", node.name)
+          field("params", node.params)
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
+      def visit_def_endless(node)
+        node(node, "def_endless") do
+          if node.target
+            field("target", node.target)
+            field("operator", node.operator)
+          end
+
+          field("name", node.name)
+          field("paren", node.paren) if node.paren
+          field("statement", node.statement)
+          comments(node)
+        end
+      end
+
+      def visit_defined(node)
+        node(node, "defined") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_defs(node)
+        node(node, "defs") do
+          field("target", node.target)
+          field("operator", node.operator)
+          field("name", node.name)
+          field("params", node.params)
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
+      def visit_do_block(node)
+        node(node, "do_block") do
+          field("block_var", node.block_var) if node.block_var
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
+      def visit_dot2(node)
+        node(node, "dot2") do
+          field("left", node.left) if node.left
+          field("right", node.right) if node.right
+          comments(node)
+        end
+      end
+
+      def visit_dot3(node)
+        node(node, "dot3") do
+          field("left", node.left) if node.left
+          field("right", node.right) if node.right
+          comments(node)
+        end
+      end
+
+      def visit_dyna_symbol(node)
+        node(node, "dyna_symbol") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_END(node)
+        node(node, "END") do
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_else(node)
+        node(node, "else") do
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_elsif(node)
+        node(node, "elsif") do
+          field("predicate", node.predicate)
+          field("statements", node.statements)
+          field("consequent", node.consequent) if node.consequent
+          comments(node)
+        end
+      end
+
+      def visit_embdoc(node)
+        node(node, "embdoc") { field("value", node.value) }
+      end
+
+      def visit_embexpr_beg(node)
+        node(node, "embexpr_beg") { field("value", node.value) }
+      end
+
+      def visit_embexpr_end(node)
+        node(node, "embexpr_end") { field("value", node.value) }
+      end
+
+      def visit_embvar(node)
+        node(node, "embvar") { field("value", node.value) }
+      end
+
+      def visit_ensure(node)
+        node(node, "ensure") do
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_excessed_comma(node)
+        visit_token(node, "excessed_comma")
+      end
+
+      def visit_fcall(node)
+        node(node, "fcall") do
+          field("value", node.value)
+          field("arguments", node.arguments) if node.arguments
+          comments(node)
+        end
+      end
+
+      def visit_field(node)
+        node(node, "field") do
+          field("parent", node.parent)
+          field("operator", node.operator)
+          field("name", node.name)
+          comments(node)
+        end
+      end
+
+      def visit_float(node)
+        visit_token(node, "float")
+      end
+
+      def visit_fndptn(node)
+        node(node, "fndptn") do
+          field("constant", node.constant) if node.constant
+          field("left", node.left)
+          list("values", node.values)
+          field("right", node.right)
+          comments(node)
+        end
+      end
+
+      def visit_for(node)
+        node(node, "for") do
+          field("index", node.index)
+          field("collection", node.collection)
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_gvar(node)
+        visit_token(node, "gvar")
+      end
+
+      def visit_hash(node)
+        node(node, "hash") do
+          list("assocs", node.assocs) if node.assocs.any?
+          comments(node)
+        end
+      end
+
+      def visit_heredoc(node)
+        node(node, "heredoc") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_heredoc_beg(node)
+        visit_token(node, "heredoc_beg")
+      end
+
+      def visit_hshptn(node)
+        node(node, "hshptn") do
+          field("constant", node.constant) if node.constant
+          pairs("keywords", node.keywords) if node.keywords.any?
+          field("keyword_rest", node.keyword_rest) if node.keyword_rest
+          comments(node)
+        end
+      end
+
+      def visit_ident(node)
+        visit_token(node, "ident")
+      end
+
+      def visit_if(node)
+        node(node, "if") do
+          field("predicate", node.predicate)
+          field("statements", node.statements)
+          field("consequent", node.consequent) if node.consequent
+          comments(node)
+        end
+      end
+
+      def visit_if_mod(node)
+        node(node, "if_mod") do
+          field("statement", node.statement)
+          field("predicate", node.predicate)
+          comments(node)
+        end
+      end
+
+      def visit_if_op(node)
+        node(node, "if_op") do
+          field("predicate", node.predicate)
+          field("truthy", node.truthy)
+          field("falsy", node.falsy)
+          comments(node)
+        end
+      end
+
+      def visit_imaginary(node)
+        visit_token(node, "imaginary")
+      end
+
+      def visit_in(node)
+        node(node, "in") do
+          field("pattern", node.pattern)
+          field("statements", node.statements)
+          field("consequent", node.consequent) if node.consequent
+          comments(node)
+        end
+      end
+
+      def visit_int(node)
+        visit_token(node, "int")
+      end
+
+      def visit_ivar(node)
+        visit_token(node, "ivar")
+      end
+
+      def visit_kw(node)
+        visit_token(node, "kw")
+      end
+
+      def visit_kwrest_param(node)
+        node(node, "kwrest_param") do
+          field("name", node.name)
+          comments(node)
+        end
+      end
+
+      def visit_label(node)
+        visit_token(node, "label")
+      end
+
+      def visit_label_end(node)
+        node(node, "label_end") { field("value", node.value) }
+      end
+
+      def visit_lambda(node)
+        node(node, "lambda") do
+          field("params", node.params)
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_lbrace(node)
+        visit_token(node, "lbrace")
+      end
+
+      def visit_lbracket(node)
+        visit_token(node, "lbracket")
+      end
+
+      def visit_lparen(node)
+        visit_token(node, "lparen")
+      end
+
+      def visit_massign(node)
+        node(node, "massign") do
+          field("target", node.target)
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_method_add_block(node)
+        node(node, "method_add_block") do
+          field("call", node.call)
+          field("block", node.block)
+          comments(node)
+        end
+      end
+
+      def visit_mlhs(node)
+        node(node, "mlhs") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_mlhs_paren(node)
+        node(node, "mlhs_paren") do
+          field("contents", node.contents)
+          comments(node)
+        end
+      end
+
+      def visit_module(node)
+        node(node, "module") do
+          field("constant", node.constant)
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
+      def visit_mrhs(node)
+        node(node, "mrhs") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_next(node)
+        node(node, "next") do
+          field("arguments", node.arguments)
+          comments(node)
+        end
+      end
+
+      def visit_not(node)
+        node(node, "not") do
+          field("statement", node.statement)
+          comments(node)
+        end
+      end
+
+      def visit_op(node)
+        visit_token(node, "op")
+      end
+
+      def visit_opassign(node)
+        node(node, "opassign") do
+          field("target", node.target)
+          field("operator", node.operator)
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_params(node)
+        node(node, "params") do
+          list("requireds", node.requireds) if node.requireds.any?
+          pairs("optionals", node.optionals) if node.optionals.any?
+          field("rest", node.rest) if node.rest
+          list("posts", node.posts) if node.posts.any?
+          pairs("keywords", node.keywords) if node.keywords.any?
+          field("keyword_rest", node.keyword_rest) if node.keyword_rest
+          field("block", node.block) if node.block
+          comments(node)
+        end
+      end
+
+      def visit_paren(node)
+        node(node, "paren") do
+          field("contents", node.contents)
+          comments(node)
+        end
+      end
+
+      def visit_period(node)
+        visit_token(node, "period")
+      end
+
+      def visit_pinned_begin(node)
+        node(node, "pinned_begin") do
+          field("statement", node.statement)
+          comments(node)
+        end
+      end
+
+      def visit_pinned_var_ref(node)
+        node(node, "pinned_var_ref") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_program(node)
+        node(node, "program") do
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_qsymbols(node)
+        node(node, "qsymbols") do
+          list("elements", node.elements)
+          comments(node)
+        end
+      end
+
+      def visit_qsymbols_beg(node)
+        node(node, "qsymbols_beg") { field("value", node.value) }
+      end
+
+      def visit_qwords(node)
+        node(node, "qwords") do
+          list("elements", node.elements)
+          comments(node)
+        end
+      end
+
+      def visit_qwords_beg(node)
+        node(node, "qwords_beg") { field("value", node.value) }
+      end
+
+      def visit_rassign(node)
+        node(node, "rassign") do
+          field("value", node.value)
+          field("operator", node.operator)
+          field("pattern", node.pattern)
+          comments(node)
+        end
+      end
+
+      def visit_rational(node)
+        visit_token(node, "rational")
+      end
+
+      def visit_rbrace(node)
+        node(node, "rbrace") { field("value", node.value) }
+      end
+
+      def visit_rbracket(node)
+        node(node, "rbracket") { field("value", node.value) }
+      end
+
+      def visit_redo(node)
+        visit_token(node, "redo")
+      end
+
+      def visit_regexp_beg(node)
+        node(node, "regexp_beg") { field("value", node.value) }
+      end
+
+      def visit_regexp_content(node)
+        node(node, "regexp_content") { list("parts", node.parts) }
+      end
+
+      def visit_regexp_end(node)
+        node(node, "regexp_end") { field("value", node.value) }
+      end
+
+      def visit_regexp_literal(node)
+        node(node, "regexp_literal") do
+          list("parts", node.parts)
+          field("options", node.options)
+          comments(node)
+        end
+      end
+
+      def visit_rescue(node)
+        node(node, "rescue") do
+          field("exception", node.exception) if node.exception
+          field("statements", node.statements)
+          field("consequent", node.consequent) if node.consequent
+          comments(node)
+        end
+      end
+
+      def visit_rescue_ex(node)
+        node(node, "rescue_ex") do
+          field("exceptions", node.exceptions)
+          field("variable", node.variable)
+          comments(node)
+        end
+      end
+
+      def visit_rescue_mod(node)
+        node(node, "rescue_mod") do
+          field("statement", node.statement)
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_rest_param(node)
+        node(node, "rest_param") do
+          field("name", node.name)
+          comments(node)
+        end
+      end
+
+      def visit_retry(node)
+        visit_token(node, "retry")
+      end
+
+      def visit_return(node)
+        node(node, "return") do
+          field("arguments", node.arguments)
+          comments(node)
+        end
+      end
+
+      def visit_return0(node)
+        visit_token(node, "return0")
+      end
+
+      def visit_rparen(node)
+        node(node, "rparen") { field("value", node.value) }
+      end
+
+      def visit_sclass(node)
+        node(node, "sclass") do
+          field("target", node.target)
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
+      def visit_statements(node)
+        node(node, "statements") do
+          list("body", node.body)
+          comments(node)
+        end
+      end
+
+      def visit_string_concat(node)
+        node(node, "string_concat") do
+          field("left", node.left)
+          field("right", node.right)
+          comments(node)
+        end
+      end
+
+      def visit_string_content(node)
+        node(node, "string_content") { list("parts", node.parts) }
+      end
+
+      def visit_string_dvar(node)
+        node(node, "string_dvar") do
+          field("variable", node.variable)
+          comments(node)
+        end
+      end
+
+      def visit_string_embexpr(node)
+        node(node, "string_embexpr") do
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_string_literal(node)
+        node(node, "string_literal") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_super(node)
+        node(node, "super") do
+          field("arguments", node.arguments)
+          comments(node)
+        end
+      end
+
+      def visit_symbeg(node)
+        node(node, "symbeg") { field("value", node.value) }
+      end
+
+      def visit_symbol_content(node)
+        node(node, "symbol_content") { field("value", node.value) }
+      end
+
+      def visit_symbol_literal(node)
+        node(node, "symbol_literal") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_symbols(node)
+        node(node, "symbols") do
+          list("elements", node.elements)
+          comments(node)
+        end
+      end
+
+      def visit_symbols_beg(node)
+        node(node, "symbols_beg") { field("value", node.value) }
+      end
+
+      def visit_tlambda(node)
+        node(node, "tlambda") { field("value", node.value) }
+      end
+
+      def visit_tlambeg(node)
+        node(node, "tlambeg") { field("value", node.value) }
+      end
+
+      def visit_top_const_field(node)
+        node(node, "top_const_field") do
+          field("constant", node.constant)
+          comments(node)
+        end
+      end
+
+      def visit_top_const_ref(node)
+        node(node, "top_const_ref") do
+          field("constant", node.constant)
+          comments(node)
+        end
+      end
+
+      def visit_tstring_beg(node)
+        node(node, "tstring_beg") { field("value", node.value) }
+      end
+
+      def visit_tstring_content(node)
+        visit_token(node, "tstring_content")
+      end
+
+      def visit_tstring_end(node)
+        node(node, "tstring_end") { field("value", node.value) }
+      end
+
+      def visit_unary(node)
+        node(node, "unary") do
+          field("operator", node.operator)
+          field("statement", node.statement)
+          comments(node)
+        end
+      end
+
+      def visit_undef(node)
+        node(node, "undef") do
+          list("symbols", node.symbols)
+          comments(node)
+        end
+      end
+
+      def visit_unless(node)
+        node(node, "unless") do
+          field("predicate", node.predicate)
+          field("statements", node.statements)
+          field("consequent", node.consequent) if node.consequent
+          comments(node)
+        end
+      end
+
+      def visit_unless_mod(node)
+        node(node, "unless_mod") do
+          field("statement", node.statement)
+          field("predicate", node.predicate)
+          comments(node)
+        end
+      end
+
+      def visit_until(node)
+        node(node, "until") do
+          field("predicate", node.predicate)
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_until_mod(node)
+        node(node, "until_mod") do
+          field("statement", node.statement)
+          field("predicate", node.predicate)
+          comments(node)
+        end
+      end
+
+      def visit_var_alias(node)
+        node(node, "var_alias") do
+          field("left", node.left)
+          field("right", node.right)
+          comments(node)
+        end
+      end
+
+      def visit_var_field(node)
+        node(node, "var_field") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_var_ref(node)
+        node(node, "var_ref") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_vcall(node)
+        node(node, "vcall") do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+
+      def visit_void_stmt(node)
+        node(node, "void_stmt") { comments(node) }
+      end
+
+      def visit_when(node)
+        node(node, "when") do
+          field("arguments", node.arguments)
+          field("statements", node.statements)
+          field("consequent", node.consequent) if node.consequent
+          comments(node)
+        end
+      end
+
+      def visit_while(node)
+        node(node, "while") do
+          field("predicate", node.predicate)
+          field("statements", node.statements)
+          comments(node)
+        end
+      end
+
+      def visit_while_mod(node)
+        node(node, "while_mod") do
+          field("statement", node.statement)
+          field("predicate", node.predicate)
+          comments(node)
+        end
+      end
+
+      def visit_word(node)
+        node(node, "word") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_words(node)
+        node(node, "words") do
+          list("elements", node.elements)
+          comments(node)
+        end
+      end
+
+      def visit_words_beg(node)
+        node(node, "words_beg") { field("value", node.value) }
+      end
+
+      def visit_xstring(node)
+        node(node, "xstring") { list("parts", node.parts) }
+      end
+
+      def visit_xstring_literal(node)
+        node(node, "xstring_literal") do
+          list("parts", node.parts)
+          comments(node)
+        end
+      end
+
+      def visit_yield(node)
+        node(node, "yield") do
+          field("arguments", node.arguments)
+          comments(node)
+        end
+      end
+
+      def visit_yield0(node)
+        visit_token(node, "yield0")
+      end
+
+      def visit_zsuper(node)
+        visit_token(node, "zsuper")
+      end
+
+      def visit___end__(node)
+        visit_token(node, "__end__")
+      end
+
+      private
+
+      def visit_token(node, type)
+        node(node, type) do
+          field("value", node.value)
+          comments(node)
+        end
+      end
+    end
+  end
+end