syntax_tree 2.3.0 → 2.4.1

data/lib/syntax_tree/visitor/json_visitor.rb

@@ -1,1316 +1,45 @@
-  # frozen_string_literal: true
+# frozen_string_literal: true
 
 module SyntaxTree
   class Visitor
-    class JSONVisitor < Visitor
-      def visit_aref(node)
-        {
-          type: :aref,
-          collection: visit(node.collection),
-          index: visit(node.index),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_aref_field(node)
-        {
-          type: :aref_field,
-          collection: visit(node.collection),
-          index: visit(node.index),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_alias(node)
-        {
-          type: :alias,
-          left: visit(node.left),
-          right: visit(node.right),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_arg_block(node)
-        {
-          type: :arg_block,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_arg_paren(node)
-        {
-          type: :arg_paren,
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_arg_star(node)
-        {
-          type: :arg_star,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_args(node)
-        {
-          type: :args,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_args_forward(node)
-        visit_token(:args_forward, node)
-      end
-
-      def visit_array(node)
-        {
-          type: :array,
-          cnts: visit(node.contents),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_aryptn(node)
-        {
-          type: :aryptn,
-          constant: visit(node.constant),
-          reqs: visit_all(node.requireds),
-          rest: visit(node.rest),
-          posts: visit_all(node.posts),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_assign(node)
-        {
-          type: :assign,
-          target: visit(node.target),
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_assoc(node)
-        {
-          type: :assoc,
-          key: visit(node.key),
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_assoc_splat(node)
-        {
-          type: :assoc_splat,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_backref(node)
-        visit_token(:backref, node)
-      end
-
-      def visit_backtick(node)
-        visit_token(:backtick, node)
-      end
-
-      def visit_bare_assoc_hash(node)
-        {
-          type: :bare_assoc_hash,
-          assocs: visit_all(node.assocs),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_BEGIN(node)
-        {
-          type: :BEGIN,
-          lbrace: visit(node.lbrace),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_begin(node)
-        {
-          type: :begin,
-          bodystmt: visit(node.bodystmt),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_binary(node)
-        {
-          type: :binary,
-          left: visit(node.left),
-          op: node.operator,
-          right: visit(node.right),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_blockarg(node)
-        {
-          type: :blockarg,
-          name: visit(node.name),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_block_var(node)
-        {
-          type: :block_var,
-          params: visit(node.params),
-          locals: visit_all(node.locals),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_bodystmt(node)
-        {
-          type: :bodystmt,
-          stmts: visit(node.statements),
-          rsc: visit(node.rescue_clause),
-          els: visit(node.else_clause),
-          ens: visit(node.ensure_clause),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_brace_block(node)
-        {
-          type: :brace_block,
-          lbrace: visit(node.lbrace),
-          block_var: visit(node.block_var),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_break(node)
-        {
-          type: :break,
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_call(node)
-        {
-          type: :call,
-          receiver: visit(node.receiver),
-          op: visit_call_operator(node.operator),
-          message: node.message == :call ? :call : visit(node.message),
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_case(node)
-        {
-          type: :case,
-          value: visit(node.value),
-          cons: visit(node.consequent),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_CHAR(node)
-        visit_token(:CHAR, node)
-      end
-
-      def visit_class(node)
-        {
-          type: :class,
-          constant: visit(node.constant),
-          superclass: visit(node.superclass),
-          bodystmt: visit(node.bodystmt),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_comma(node)
-        visit_token(:comma, node)
-      end
-
-      def visit_command(node)
-        {
-          type: :command,
-          message: visit(node.message),
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_command_call(node)
-        {
-          type: :command_call,
-          receiver: visit(node.receiver),
-          op: visit_call_operator(node.operator),
-          message: visit(node.message),
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_comment(node)
-        {
-          type: :comment,
-          value: node.value,
-          inline: node.inline,
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_const(node)
-        visit_token(:const, node)
-      end
-
-      def visit_const_path_field(node)
-        {
-          type: :const_path_field,
-          parent: visit(node.parent),
-          constant: visit(node.constant),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_const_path_ref(node)
-        {
-          type: :const_path_ref,
-          parent: visit(node.parent),
-          constant: visit(node.constant),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_const_ref(node)
-        {
-          type: :const_ref,
-          constant: visit(node.constant),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_cvar(node)
-        visit_token(:cvar, node)
-      end
-
-      def visit_def(node)
-        {
-          type: :def,
-          name: visit(node.name),
-          params: visit(node.params),
-          bodystmt: visit(node.bodystmt),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_def_endless(node)
-        {
-          type: :def_endless,
-          name: visit(node.name),
-          paren: visit(node.paren),
-          stmt: visit(node.statement),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_defined(node)
-        visit_token(:defined, node)
-      end
-
-      def visit_defs(node)
-        {
-          type: :defs,
-          target: visit(node.target),
-          op: visit(node.operator),
-          name: visit(node.name),
-          params: visit(node.params),
-          bodystmt: visit(node.bodystmt),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_do_block(node)
-        {
-          type: :do_block,
-          keyword: visit(node.keyword),
-          block_var: visit(node.block_var),
-          bodystmt: visit(node.bodystmt),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_dot2(node)
-        {
-          type: :dot2,
-          left: visit(node.left),
-          right: visit(node.right),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_dot3(node)
-        {
-          type: :dot3,
-          left: visit(node.left),
-          right: visit(node.right),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_dyna_symbol(node)
-        {
-          type: :dyna_symbol,
-          parts: visit_all(node.parts),
-          quote: node.quote,
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_END(node)
-        {
-          type: :END,
-          lbrace: visit(node.lbrace),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_else(node)
-        {
-          type: :else,
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_elsif(node)
-        {
-          type: :elsif,
-          pred: visit(node.predicate),
-          stmts: visit(node.statements),
-          cons: visit(node.consequent),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_embdoc(node)
-        {
-          type: :embdoc,
-          value: node.value,
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_embexpr_beg(node)
-        {
-          type: :embexpr_beg,
-          value: node.value,
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_embexpr_end(node)
-        {
-          type: :embexpr_end,
-          value: node.value,
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_embvar(node)
-        {
-          type: :embvar,
-          value: node.value,
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_ensure(node)
-        {
-          type: :ensure,
-          keyword: visit(node.keyword),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_excessed_comma(node)
-        visit_token(:excessed_comma, node)
-      end
-
-      def visit_fcall(node)
-        {
-          type: :fcall,
-          value: visit(node.value),
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_field(node)
-        {
-          type: :field,
-          parent: visit(node.parent),
-          op: visit_call_operator(node.operator),
-          name: visit(node.name),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_float(node)
-        visit_token(:float, node)
-      end
-
-      def visit_fndptn(node)
-        {
-          type: :fndptn,
-          constant: visit(node.constant),
-          left: visit(node.left),
-          values: visit_all(node.values),
-          right: visit(node.right),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_for(node)
-        {
-          type: :for,
-          index: visit(node.index),
-          collection: visit(node.collection),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
+    # This visitor transforms the AST into a hash that contains only primitives
+    # that can be easily serialized into JSON.
+    class JSONVisitor < FieldVisitor
+      attr_reader :target
 
-      def visit_gvar(node)
-        visit_token(:gvar, node)
+      def initialize
+        @target = nil
       end
 
-      def visit_hash(node)
-        {
-          type: :hash,
-          assocs: visit_all(node.assocs),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_heredoc(node)
-        {
-          type: :heredoc,
-          beging: visit(node.beginning),
-          ending: node.ending,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_heredoc_beg(node)
-        visit_token(:heredoc_beg, node)
-      end
-
-      def visit_hshptn(node)
-        {
-          type: :hshptn,
-          constant: visit(node.constant),
-          keywords: node.keywords.map { |(name, value)| [visit(name), visit(value)] },
-          kwrest: visit(node.keyword_rest),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_ident(node)
-        visit_token(:ident, node)
-      end
-
-      def visit_if(node)
-        {
-          type: :if,
-          pred: visit(node.predicate),
-          stmts: visit(node.statements),
-          cons: visit(node.consequent),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_if_mod(node)
-        {
-          type: :if_mod,
-          stmt: visit(node.statement),
-          pred: visit(node.predicate),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_if_op(node)
-        {
-          type: :ifop,
-          pred: visit(node.predicate),
-          tthy: visit(node.truthy),
-          flsy: visit(node.falsy),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_imaginary(node)
-        visit_token(:imaginary, node)
-      end
-
-      def visit_in(node)
-        {
-          type: :in,
-          pattern: visit(node.pattern),
-          stmts: visit(node.statements),
-          cons: visit(node.consequent),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_int(node)
-        visit_token(:int, node)
-      end
-
-      def visit_ivar(node)
-        visit_token(:ivar, node)
-      end
-
-      def visit_kw(node)
-        visit_token(:kw, node)
-      end
-
-      def visit_kwrest_param(node)
-        {
-          type: :kwrest_param,
-          name: visit(node.name),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_label(node)
-        visit_token(:label, node)
-      end
-
-      def visit_label_end(node)
-        visit_token(:label_end, node)
-      end
-
-      def visit_lambda(node)
-        {
-          type: :lambda,
-          params: visit(node.params),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_lbrace(node)
-        visit_token(:lbrace, node)
-      end
-
-      def visit_lbracket(node)
-        visit_token(:lbracket, node)
-      end
-
-      def visit_lparen(node)
-        visit_token(:lparen, node)
-      end
-
-      def visit_massign(node)
-        {
-          type: :massign,
-          target: visit(node.target),
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_method_add_block(node)
-        {
-          type: :method_add_block,
-          call: visit(node.call),
-          block: visit(node.block),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_mlhs(node)
-        {
-          type: :mlhs,
-          parts: visit_all(node.parts),
-          comma: node.comma,
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_mlhs_paren(node)
-        {
-          type: :mlhs_paren,
-          cnts: visit(node.contents),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_module(node)
-        {
-          type: :module,
-          constant: visit(node.constant),
-          bodystmt: visit(node.bodystmt),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_mrhs(node)
-        {
-          type: :mrhs,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_next(node)
-        {
-          type: :next,
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_not(node)
-        {
-          type: :not,
-          value: visit(node.statement),
-          paren: node.parentheses,
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_op(node)
-        visit_token(:op, node)
-      end
-
-      def visit_opassign(node)
-        {
-          type: :opassign,
-          target: visit(node.target),
-          op: visit(node.operator),
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_params(node)
-        {
-          type: :params,
-          reqs: visit_all(node.requireds),
-          opts: node.optionals.map { |(name, value)| [visit(name), visit(value)] },
-          rest: visit(node.rest),
-          posts: visit_all(node.posts),
-          keywords: node.keywords.map { |(name, value)| [visit(name), visit(value || nil)] },
-          kwrest: node.keyword_rest == :nil ? "nil" : visit(node.keyword_rest),
-          block: visit(node.block),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_paren(node)
-        {
-          type: :paren,
-          lparen: visit(node.lparen),
-          cnts: visit(node.contents),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_period(node)
-        visit_token(:period, node)
-      end
-
-      def visit_pinned_begin(node)
-        {
-          type: :pinned_begin,
-          stmt: visit(node.statement),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_pinned_var_ref(node)
-        {
-          type: :pinned_var_ref,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_program(node)
-        {
-          type: :program,
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_qsymbols(node)
-        {
-          type: :qsymbols,
-          elems: visit_all(node.elements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_qsymbols_beg(node)
-        visit_token(:qsymbols_beg, node)
-      end
-
-      def visit_qwords(node)
-        {
-          type: :qwords,
-          elems: visit_all(node.elements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_qwords_beg(node)
-        visit_token(:qwords_beg, node)
-      end
-
-      def visit_rassign(node)
-        {
-          type: :rassign,
-          value: visit(node.value),
-          op: visit(node.operator),
-          pattern: visit(node.pattern),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_rational(node)
-        visit_token(:rational, node)
-      end
-
-      def visit_rbrace(node)
-        visit_token(:rbrace, node)
-      end
-
-      def visit_rbracket(node)
-        visit_token(:rbracket, node)
-      end
-
-      def visit_redo(node)
-        visit_token(:redo, node)
-      end
-
-      def visit_regexp_beg(node)
-        visit_token(:regexp_beg, node)
-      end
-
-      def visit_regexp_content(node)
-        {
-          type: :regexp_content,
-          beging: node.beginning,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_regexp_end(node)
-        visit_token(:regexp_end, node)
-      end
-
-      def visit_regexp_literal(node)
-        {
-          type: :regexp_literal,
-          beging: node.beginning,
-          ending: node.ending,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_rescue(node)
-        {
-          type: :rescue,
-          extn: visit(node.exception),
-          stmts: visit(node.statements),
-          cons: visit(node.consequent),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_rescue_ex(node)
-        {
-          type: :rescue_ex,
-          extns: visit(node.exceptions),
-          var: visit(node.variable),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_rescue_mod(node)
-        {
-          type: :rescue_mod,
-          stmt: visit(node.statement),
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_rest_param(node)
-        {
-          type: :rest_param,
-          name: visit(node.name),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_retry(node)
-        visit_token(:retry, node)
-      end
-
-      def visit_return(node)
-        {
-          type: :return,
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_return0(node)
-        visit_token(:return0, node)
-      end
-
-      def visit_rparen(node)
-        visit_token(:rparen, node)
-      end
-
-      def visit_sclass(node)
-        {
-          type: :sclass,
-          target: visit(node.target),
-          bodystmt: visit(node.bodystmt),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_statements(node)
-        {
-          type: :statements,
-          body: visit_all(node.body),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_string_concat(node)
-        {
-          type: :string_concat,
-          left: visit(node.left),
-          right: visit(node.right),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_string_content(node)
-        {
-          type: :string_content,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_string_dvar(node)
-        {
-          type: :string_dvar,
-          var: visit(node.variable),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_string_embexpr(node)
-        {
-          type: :string_embexpr,
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_string_literal(node)
-        {
-          type: :string_literal,
-          parts: visit_all(node.parts),
-          quote: node.quote,
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_super(node)
-        {
-          type: :super,
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_symbeg(node)
-        visit_token(:symbeg, node)
-      end
-
-      def visit_symbol_content(node)
-        {
-          type: :symbol_content,
-          value: visit(node.value),
-          loc: visit_location(node.location)
-        }
-      end
-
-      def visit_symbol_literal(node)
-        {
-          type: :symbol_literal,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_symbols(node)
-        {
-          type: :symbols,
-          elems: visit_all(node.elements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_symbols_beg(node)
-        visit_token(:symbols_beg, node)
-      end
-
-      def visit_tlambda(node)
-        visit_token(:tlambda, node)
-      end
-
-      def visit_tlambeg(node)
-        visit_token(:tlambeg, node)
-      end
-
-      def visit_top_const_field(node)
-        {
-          type: :top_const_field,
-          constant: visit(node.constant),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_top_const_ref(node)
-        {
-          type: :top_const_ref,
-          constant: visit(node.constant),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_tstring_beg(node)
-        visit_token(:tstring_beg, node)
-      end
-
-      def visit_tstring_content(node)
-        visit_token(:tstring_content, node)
-      end
-
-      def visit_tstring_end(node)
-        visit_token(:tstring_end, node)
-      end
-
-      def visit_unary(node)
-        {
-          type: :unary,
-          op: node.operator,
-          value: visit(node.statement),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_undef(node)
-        {
-          type: :undef,
-          syms: visit_all(node.symbols),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_unless(node)
-        {
-          type: :unless,
-          pred: visit(node.predicate),
-          stmts: visit(node.statements),
-          cons: visit(node.consequent),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_unless_mod(node)
-        {
-          type: :unless_mod,
-          stmt: visit(node.statement),
-          pred: visit(node.predicate),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_until(node)
-        {
-          type: :until,
-          pred: visit(node.predicate),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_until_mod(node)
-        {
-          type: :until_mod,
-          stmt: visit(node.statement),
-          pred: visit(node.predicate),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_var_alias(node)
-        {
-          type: :var_alias,
-          left: visit(node.left),
-          right: visit(node.right),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_var_field(node)
-        {
-          type: :var_field,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_var_ref(node)
-        {
-          type: :var_ref,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_vcall(node)
-        {
-          type: :vcall,
-          value: visit(node.value),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_void_stmt(node)
-        {
-          type: :void_stmt,
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_when(node)
-        {
-          type: :when,
-          args: visit(node.arguments),
-          stmts: visit(node.statements),
-          cons: visit(node.consequent),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_while(node)
-        {
-          type: :while,
-          pred: visit(node.predicate),
-          stmts: visit(node.statements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_while_mod(node)
-        {
-          type: :while_mod,
-          stmt: visit(node.statement),
-          pred: visit(node.predicate),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_word(node)
-        {
-          type: :word,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_words(node)
-        {
-          type: :words,
-          elems: visit_all(node.elements),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
-
-      def visit_words_beg(node)
-        visit_token(:words_beg, node)
-      end
+      private
 
-      def visit_xstring(node)
-        {
-          type: :xstring,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location)
-        }
+      def comments(node)
+        target[:comments] = visit_all(node.comments)
       end
 
-      def visit_xstring_literal(node)
-        {
-          type: :xstring_literal,
-          parts: visit_all(node.parts),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
+      def field(name, value)
+        target[name] = value.is_a?(Node) ? visit(value) : value
       end
 
-      def visit_yield(node)
-        {
-          type: :yield,
-          args: visit(node.arguments),
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
+      def list(name, values)
+        target[name] = visit_all(values)
       end
 
-      def visit_yield0(node)
-        visit_token(:yield0, node)
+      def node(node, type)
+        previous = @target
+        @target = { type: type, location: visit_location(node.location) }
+        yield
+        @target
+      ensure
+        @target = previous
       end
 
-      def visit_zsuper(node)
-        visit_token(:zsuper, node)
+      def pairs(name, values)
+        target[name] = values.map { |(key, value)| [visit(key), visit(value)] }
       end
 
-      def visit___end__(node)
-        visit_token(:__end__, node)
-      end
-
-      private
-
-      def visit_call_operator(operator)
-        operator == :"::" ? :"::" : visit(operator)
+      def text(name, value)
+        target[name] = value
       end
 
       def visit_location(location)
@@ -1321,15 +50,6 @@ module SyntaxTree
           location.end_char
         ]
       end
-
-      def visit_token(type, node)
-        {
-          type: type,
-          value: node.value,
-          loc: visit_location(node.location),
-          cmts: visit_all(node.comments)
-        }
-      end
     end
   end
 end