rbi 0.0.1 → 0.0.2

data/lib/rbi/parser.rb

@@ -0,0 +1,449 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "unparser"
+
+module RBI
+  class Parser
+    extend T::Sig
+
+    class Error < StandardError; end
+
+    # opt-in to most recent AST format
+    ::Parser::Builders::Default.emit_lambda               = true
+    ::Parser::Builders::Default.emit_procarg0             = true
+    ::Parser::Builders::Default.emit_encoding             = true
+    ::Parser::Builders::Default.emit_index                = true
+    ::Parser::Builders::Default.emit_arg_inside_procarg0  = true
+
+    sig { params(string: String).returns(Tree) }
+    def self.parse_string(string)
+      Parser.new.parse_string(string)
+    end
+
+    sig { params(path: String).returns(Tree) }
+    def self.parse_file(path)
+      Parser.new.parse_file(path)
+    end
+
+    sig { params(string: String).returns(Tree) }
+    def parse_string(string)
+      parse(string, file: "-")
+    rescue ::Parser::SyntaxError => e
+      raise Error, e.message
+    end
+
+    sig { params(path: String).returns(Tree) }
+    def parse_file(path)
+      parse(::File.read(path), file: path)
+    rescue ::Parser::SyntaxError => e
+      raise Error, e.message
+    end
+
+    private
+
+    sig { params(content: String, file: String).returns(Tree) }
+    def parse(content, file:)
+      node, comments = Unparser.parse_with_comments(content)
+      assoc = ::Parser::Source::Comment.associate_locations(node, comments)
+      builder = TreeBuilder.new(file: file, comments: assoc)
+      builder.visit(node)
+      builder.assoc_dangling_comments(comments)
+      builder.tree
+    end
+  end
+
+  class ASTVisitor
+    extend T::Helpers
+    extend T::Sig
+
+    abstract!
+
+    sig { params(nodes: T::Array[AST::Node]).void }
+    def visit_all(nodes)
+      nodes.each { |node| visit(node) }
+    end
+
+    sig { abstract.params(node: T.nilable(AST::Node)).void }
+    def visit(node); end
+
+    private
+
+    sig { params(node: AST::Node).returns(String) }
+    def visit_name(node)
+      T.must(ConstBuilder.visit(node))
+    end
+
+    sig { params(node: AST::Node).returns(String) }
+    def visit_expr(node)
+      Unparser.unparse(node)
+    end
+  end
+
+  class TreeBuilder < ASTVisitor
+    extend T::Sig
+
+    sig { returns(Tree) }
+    attr_reader :tree
+
+    sig do
+      params(
+        file: String,
+        comments: T.nilable(T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]])
+      ).void
+    end
+    def initialize(file:, comments: nil)
+      super()
+      @file = file
+      @comments = comments
+      @tree = T.let(Tree.new, Tree)
+      @scopes_stack = T.let([@tree], T::Array[Tree])
+      @last_sigs = T.let([], T::Array[RBI::Sig])
+    end
+
+    sig { override.params(node: T.nilable(Object)).void }
+    def visit(node)
+      return unless node.is_a?(AST::Node)
+      case node.type
+      when :module, :class, :sclass
+        visit_scope(node)
+      when :casgn
+        visit_const_assign(node)
+      when :def, :defs
+        visit_def(node)
+      when :send
+        visit_send(node)
+      when :block
+        visit_block(node)
+      else
+        visit_all(node.children)
+      end
+    end
+
+    sig { params(comments: T::Array[::Parser::Source::Comment]).void }
+    def assoc_dangling_comments(comments)
+      return unless tree.empty?
+      comments.each do |comment|
+        text = comment.text[1..-1].strip
+        loc = ast_to_rbi_loc(comment.location)
+        tree.comments << Comment.new(text, loc: loc)
+      end
+    end
+
+    private
+
+    sig { params(node: AST::Node).void }
+    def visit_scope(node)
+      loc = node_loc(node)
+      comments = node_comments(node)
+
+      scope = case node.type
+      when :module
+        name = visit_name(node.children[0])
+        Module.new(name, loc: loc, comments: comments)
+      when :class
+        name = visit_name(node.children[0])
+        superclass_name = ConstBuilder.visit(node.children[1])
+        Class.new(name, superclass_name: superclass_name, loc: loc, comments: comments)
+      when :sclass
+        SingletonClass.new(loc: loc, comments: comments)
+      else
+        raise "Unsupported node #{node.type}"
+      end
+      current_scope << scope
+
+      @scopes_stack << scope
+      visit_all(node.children)
+      @scopes_stack.pop
+    end
+
+    sig { params(node: AST::Node).void }
+    def visit_const_assign(node)
+      name = visit_name(node)
+      value = visit_expr(node.children[2])
+      loc = node_loc(node)
+      comments = node_comments(node)
+
+      current_scope << Const.new(name, value, loc: loc, comments: comments)
+    end
+
+    sig { params(node: AST::Node).void }
+    def visit_def(node)
+      current_scope << case node.type
+      when :def
+        Method.new(
+          node.children[0].to_s,
+          params: node.children[1].children.map { |child| visit_param(child) },
+          sigs: current_sigs,
+          loc: node_loc(node),
+          comments: node_comments(node)
+        )
+      when :defs
+        Method.new(
+          node.children[1].to_s,
+          params: node.children[2].children.map { |child| visit_param(child) },
+          is_singleton: true,
+          sigs: current_sigs,
+          loc: node_loc(node),
+          comments: node_comments(node)
+        )
+      else
+        raise "Unsupported node #{node.type}"
+      end
+    end
+
+    sig { params(node: AST::Node).returns(Param) }
+    def visit_param(node)
+      name = node.children[0].to_s
+      loc = node_loc(node)
+      comments = node_comments(node)
+
+      case node.type
+      when :arg
+        Param.new(name, loc: loc, comments: comments)
+      when :optarg
+        value = visit_expr(node.children[1])
+        OptParam.new(name, value, loc: loc, comments: comments)
+      when :restarg
+        RestParam.new(name, loc: loc, comments: comments)
+      when :kwarg
+        KwParam.new(name, loc: loc, comments: comments)
+      when :kwoptarg
+        value = visit_expr(node.children[1])
+        KwOptParam.new(name, value, loc: loc, comments: comments)
+      when :kwrestarg
+        KwRestParam.new(name, loc: loc, comments: comments)
+      when :blockarg
+        BlockParam.new(name, loc: loc, comments: comments)
+      else
+        raise "Unsupported node #{node.type}"
+      end
+    end
+
+    sig { params(node: AST::Node).void }
+    def visit_send(node)
+      recv = node.children[0]
+      return if recv && recv != :self
+
+      method_name = node.children[1]
+      loc = node_loc(node)
+      comments = node_comments(node)
+
+      current_scope << case method_name
+      when :attr_reader
+        symbols = node.children[2..-1].map { |child| child.children[0] }
+        AttrReader.new(*symbols, sigs: current_sigs, loc: loc, comments: comments)
+      when :attr_writer
+        symbols = node.children[2..-1].map { |child| child.children[0] }
+        AttrWriter.new(*symbols, sigs: current_sigs, loc: loc, comments: comments)
+      when :attr_accessor
+        symbols = node.children[2..-1].map { |child| child.children[0] }
+        AttrAccessor.new(*symbols, sigs: current_sigs, loc: loc, comments: comments)
+      when :include
+        names = node.children[2..-1].map { |child| visit_name(child) }
+        Include.new(*names, loc: loc, comments: comments)
+      when :extend
+        names = node.children[2..-1].map { |child| visit_name(child) }
+        Extend.new(*names, loc: loc, comments: comments)
+      when :abstract!, :sealed!, :interface!
+        Helper.new(method_name.to_s.delete_suffix("!"), loc: loc, comments: comments)
+      when :mixes_in_class_methods
+        names = node.children[2..-1].map { |child| visit_name(child) }
+        MixesInClassMethods.new(*names, loc: loc, comments: comments)
+      when :public, :protected, :private
+        Visibility.new(method_name, loc: loc)
+      when :prop
+        name, type, default_value = visit_struct_prop(node)
+        TStructProp.new(name, type, default: default_value, loc: loc, comments: comments)
+      when :const
+        name, type, default_value = visit_struct_prop(node)
+        TStructConst.new(name, type, default: default_value, loc: loc, comments: comments)
+      else
+        raise "Unsupported node #{node.type} with name #{method_name}"
+      end
+    end
+
+    sig { params(node: AST::Node).void }
+    def visit_block(node)
+      name = node.children[0].children[1]
+
+      case name
+      when :sig
+        @last_sigs << visit_sig(node)
+      when :enums
+        current_scope << visit_enum(node)
+      else
+        raise "Unsupported node #{node.type} with name #{name}"
+      end
+    end
+
+    sig { params(node: AST::Node).returns([String, String, T.nilable(String)]) }
+    def visit_struct_prop(node)
+      name = node.children[2].children[0].to_s
+      type = visit_expr(node.children[3])
+      has_default = node.children[4]
+        &.children&.fetch(0, nil)
+        &.children&.fetch(0, nil)
+        &.children&.fetch(0, nil) == :default
+      default_value = if has_default
+        visit_expr(node.children.fetch(4, nil)
+          &.children&.fetch(0, nil)
+          &.children&.fetch(1, nil))
+      end
+      [name, type, default_value]
+    end
+
+    sig { params(node: AST::Node).returns(Sig) }
+    def visit_sig(node)
+      sig = SigBuilder.build(node)
+      sig.loc = node_loc(node)
+      sig
+    end
+
+    sig { params(node: AST::Node).returns(TEnumBlock) }
+    def visit_enum(node)
+      enum = TEnumBlock.new
+      node.children[2].children.each do |child|
+        enum << visit_name(child)
+      end
+      enum.loc = node_loc(node)
+      enum
+    end
+
+    sig { params(node: AST::Node).returns(Loc) }
+    def node_loc(node)
+      ast_to_rbi_loc(node.location)
+    end
+
+    sig { params(ast_loc: ::Parser::Source::Map).returns(Loc) }
+    def ast_to_rbi_loc(ast_loc)
+      Loc.new(
+        file: @file,
+        begin_line: ast_loc.line,
+        begin_column: ast_loc.column,
+        end_line: ast_loc.last_line,
+        end_column: ast_loc.last_column
+      )
+    end
+
+    sig { params(node: AST::Node).returns(T::Array[Comment]) }
+    def node_comments(node)
+      return [] unless @comments
+      comments = @comments[node.location]
+      return [] unless comments
+      comments.map do |comment|
+        text = comment.text[1..-1].strip
+        loc = ast_to_rbi_loc(comment.location)
+        Comment.new(text, loc: loc)
+      end
+    end
+
+    sig { returns(Tree) }
+    def current_scope
+      T.must(@scopes_stack.last) # Should never be nil since we create a Tree as the root
+    end
+
+    sig { returns(T::Array[Sig]) }
+    def current_sigs
+      sigs = @last_sigs.dup
+      @last_sigs.clear
+      sigs
+    end
+  end
+
+  class ConstBuilder < ASTVisitor
+    extend T::Sig
+
+    sig { params(node: T.nilable(AST::Node)).returns(T.nilable(String)) }
+    def self.visit(node)
+      v = ConstBuilder.new
+      v.visit(node)
+      return nil if v.names.empty?
+      v.names.join("::")
+    end
+
+    sig { returns(T::Array[String]) }
+    attr_accessor :names
+
+    sig { void }
+    def initialize
+      super
+      @names = T.let([], T::Array[String])
+    end
+
+    sig { override.params(node: T.nilable(AST::Node)).void }
+    def visit(node)
+      return unless node
+      case node.type
+      when :const, :casgn
+        visit(node.children[0])
+        @names << node.children[1].to_s
+      when :cbase
+        @names << ""
+      when :sym
+        @names << ":#{node.children[0]}"
+      end
+    end
+  end
+
+  class SigBuilder < ASTVisitor
+    extend T::Sig
+
+    sig { params(node: AST::Node).returns(Sig) }
+    def self.build(node)
+      v = SigBuilder.new
+      v.visit_all(node.children[2..-1])
+      v.current
+    end
+
+    sig { returns(Sig) }
+    attr_accessor :current
+
+    sig { void }
+    def initialize
+      super
+      @current = T.let(Sig.new, Sig)
+    end
+
+    sig { override.params(node: T.nilable(AST::Node)).void }
+    def visit(node)
+      return unless node
+      case node.type
+      when :send
+        visit_send(node)
+      end
+    end
+
+    sig { params(node: AST::Node).void }
+    def visit_send(node)
+      visit(node.children[0]) if node.children[0]
+      name = node.children[1]
+      case name
+      when :abstract
+        @current.is_abstract = true
+      when :override
+        @current.is_override = true
+      when :overridable
+        @current.is_overridable = true
+      when :checked
+        @current.checked = node.children[2].children[0]
+      when :type_parameters
+        node.children[2..-1].each do |child|
+          @current.type_params << child.children[0].to_s
+        end
+      when :params
+        node.children[2].children.each do |child|
+          name = child.children[0].children[0].to_s
+          type = visit_expr(child.children[1])
+          @current << SigParam.new(name, type)
+        end
+      when :returns
+        @current.return_type = visit_expr(node.children[2])
+      when :void
+        @current.return_type = nil
+      else
+        raise "#{node.location.line}: Unhandled #{name}"
+      end
+    end
+  end
+end

data/lib/rbi/printer.rb

@@ -0,0 +1,643 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Printer < Visitor
+    extend T::Sig
+
+    sig { returns(T::Boolean) }
+    attr_accessor :print_locs, :in_visibility_group
+
+    sig { returns(T.nilable(Node)) }
+    attr_reader :previous_node
+
+    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+    def initialize(out: $stdout, indent: 0, print_locs: false)
+      super()
+      @out = out
+      @current_indent = indent
+      @print_locs = print_locs
+      @in_visibility_group = T.let(false, T::Boolean)
+      @previous_node = T.let(nil, T.nilable(Node))
+    end
+
+    # Printing
+
+    sig { void }
+    def indent
+      @current_indent += 2
+    end
+
+    sig { void }
+    def dedent
+      @current_indent -= 2
+    end
+
+    # Print a string without indentation nor `\n` at the end.
+    sig { params(string: String).void }
+    def print(string)
+      @out.print(string)
+    end
+
+    # Print a string without indentation but with a `\n` at the end.
+    sig { params(string: T.nilable(String)).void }
+    def printn(string = nil)
+      print(string) if string
+      print("\n")
+    end
+
+    # Print a string with indentation but without a `\n` at the end.
+    sig { params(string: T.nilable(String)).void }
+    def printt(string = nil)
+      print(" " * @current_indent)
+      print(string) if string
+    end
+
+    # Print a string with indentation and `\n` at the end.
+    sig { params(string: String).void }
+    def printl(string)
+      printt
+      printn(string)
+    end
+
+    sig { params(file: File).void }
+    def visit_file(file)
+      file.accept_printer(self)
+    end
+
+    sig { override.params(node: T.nilable(Node)).void }
+    def visit(node)
+      return unless node
+      node.accept_printer(self)
+    end
+
+    sig { override.params(nodes: T::Array[Node]).void }
+    def visit_all(nodes)
+      previous_node = @previous_node
+      @previous_node = nil
+      nodes.each do |node|
+        visit(node)
+        @previous_node = node
+      end
+      @previous_node = previous_node
+    end
+  end
+
+  class File
+    extend T::Sig
+
+    sig { params(v: Printer).void }
+    def accept_printer(v)
+      strictness = self.strictness
+      if strictness
+        v.printl("# typed: #{strictness}")
+      end
+      unless comments.empty?
+        v.printn if strictness
+        v.visit_all(comments)
+      end
+
+      unless root.empty?
+        v.printn if strictness || !comments.empty?
+        v.visit(root)
+      end
+    end
+
+    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+    def print(out: $stdout, indent: 0, print_locs: false)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs)
+      p.visit_file(self)
+    end
+
+    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
+    def string(indent: 0, print_locs: false)
+      out = StringIO.new
+      print(out: out, indent: indent, print_locs: print_locs)
+      out.string
+    end
+  end
+
+  class Node
+    extend T::Sig
+
+    sig { abstract.params(v: Printer).void }
+    def accept_printer(v); end
+
+    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+    def print(out: $stdout, indent: 0, print_locs: false)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs)
+      p.visit(self)
+    end
+
+    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
+    def string(indent: 0, print_locs: false)
+      out = StringIO.new
+      print(out: out, indent: indent, print_locs: print_locs)
+      out.string
+    end
+
+    sig { returns(T::Boolean) }
+    def oneline?
+      true
+    end
+  end
+
+  class NodeWithComments
+    extend T::Sig
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      comments.empty?
+    end
+  end
+
+  class Comment
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      text = self.text.strip
+      v.printt("#")
+      v.print(" #{text}") unless text.empty?
+      v.printn
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.visit_all(comments)
+      v.printn if !comments.empty? && !empty?
+      v.visit_all(nodes)
+    end
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      comments.empty? && empty?
+    end
+  end
+
+  class Scope
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+
+      print_header(v)
+      print_body(v)
+    end
+
+    sig { abstract.params(v: Printer).void }
+    def print_header(v); end
+
+    sig { params(v: Printer).void }
+    def print_body(v)
+      unless empty?
+        v.indent
+        v.visit_all(nodes)
+        v.dedent
+        v.printl("end")
+      end
+    end
+  end
+
+  class Module
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def print_header(v)
+      v.printt("module #{name}")
+      if empty?
+        v.printn("; end")
+      else
+        v.printn
+      end
+    end
+  end
+
+  class Class
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def print_header(v)
+      v.printt("class #{name}")
+      superclass = superclass_name
+      v.print(" < #{superclass}") if superclass
+      if empty?
+        v.printn("; end")
+      else
+        v.printn
+      end
+    end
+  end
+
+  class SingletonClass
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def print_header(v)
+      v.printt("class << self")
+      if empty?
+        v.printn("; end")
+      else
+        v.printn
+      end
+    end
+  end
+
+  class Const
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      v.printl("#{name} = #{value}")
+    end
+  end
+
+  class Attr
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.visit_all(comments)
+      sigs.each { |sig| v.visit(sig) }
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.printt
+      unless v.in_visibility_group || visibility == Visibility::Public
+        v.print(visibility.visibility.to_s)
+        v.print(" ")
+      end
+      case self
+      when AttrAccessor
+        v.print("attr_accessor")
+      when AttrReader
+        v.print("attr_reader")
+      when AttrWriter
+        v.print("attr_writer")
+      end
+      unless names.empty?
+        v.print(" ")
+        v.print(names.map { |name| ":#{name}" }.join(", "))
+      end
+      v.printn
+    end
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      comments.empty? && sigs.empty?
+    end
+  end
+
+  class Method
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.visit_all(comments)
+      v.visit_all(sigs)
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.printt
+      unless v.in_visibility_group || visibility == Visibility::Public
+        v.print(visibility.visibility.to_s)
+        v.print(" ")
+      end
+      v.print("def ")
+      v.print("self.") if is_singleton
+      v.print(name)
+      unless params.empty?
+        v.print("(")
+        if inline_params?
+          params.each_with_index do |param, index|
+            v.print(", ") if index > 0
+            v.visit(param)
+          end
+        else
+          v.printn
+          v.indent
+          params.each_with_index do |param, pindex|
+            v.printt
+            v.visit(param)
+            v.print(",") if pindex < params.size - 1
+            param.comments.each_with_index do |comment, cindex|
+              if cindex > 0
+                param.print_comment_leading_space(v)
+              else
+                v.print(" ")
+              end
+              v.print("# #{comment.text.strip}")
+            end
+            v.printn
+          end
+          v.dedent
+        end
+        v.print(")")
+      end
+      v.print("; end")
+      v.printn
+    end
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      comments.empty? && sigs.empty? && inline_params?
+    end
+
+    sig { returns(T::Boolean) }
+    def inline_params?
+      params.all? { |p| p.comments.empty? }
+    end
+  end
+
+  class Param
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print(name.to_s)
+    end
+
+    sig { params(v: Printer).void }
+    def print_comment_leading_space(v)
+      v.printn
+      v.printt
+      v.print(" " * (name.size + 2))
+    end
+  end
+
+  class OptParam
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print("#{name} = #{value}")
+    end
+
+    sig { override.params(v: Printer).void }
+    def print_comment_leading_space(v)
+      super
+      v.print(" " * (value.size + 3))
+    end
+  end
+
+  class RestParam
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print("*#{name}")
+    end
+
+    sig { override.params(v: Printer).void }
+    def print_comment_leading_space(v)
+      super
+      v.print(" ")
+    end
+  end
+
+  class KwParam
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print("#{name}:")
+    end
+
+    sig { override.params(v: Printer).void }
+    def print_comment_leading_space(v)
+      super
+      v.print(" ")
+    end
+  end
+
+  class KwOptParam
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print("#{name}: #{value}")
+    end
+
+    sig { override.params(v: Printer).void }
+    def print_comment_leading_space(v)
+      v.printn
+      v.printt
+      v.print(" " * (name.size + 2))
+      v.print(" " * (value.size + 2))
+    end
+  end
+
+  class KwRestParam
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print("**#{name}")
+    end
+
+    sig { override.params(v: Printer).void }
+    def print_comment_leading_space(v)
+      super
+      v.print("  ")
+    end
+  end
+
+  class BlockParam
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print("&#{name}")
+    end
+  end
+
+  class Mixin
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      case self
+      when Include
+        v.printt("include")
+      when Extend
+        v.printt("extend")
+      when MixesInClassMethods
+        v.printt("mixes_in_class_methods")
+      end
+      v.printn(" #{names.join(", ")}")
+    end
+  end
+
+  class Visibility
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.printl(visibility.to_s)
+    end
+  end
+
+  class Sig
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.printt("sig { ")
+      v.print("abstract.") if is_abstract
+      v.print("override.") if is_override
+      v.print("overridable.") if is_overridable
+      unless type_params.empty?
+        v.print("type_parameters(")
+        type_params.each_with_index do |param, index|
+          v.print(":#{param}")
+          v.print(", ") if index < type_params.length - 1
+        end
+        v.print(").")
+      end
+      unless params.empty?
+        v.print("params(")
+        params.each_with_index do |param, index|
+          v.visit(param)
+          v.print(", ") if index < params.length - 1
+        end
+        v.print(").")
+      end
+      if return_type && return_type != "void"
+        v.print("returns(#{return_type})")
+      else
+        v.print("void")
+      end
+      if checked
+        v.print(".checked(:#{checked})")
+      end
+      v.printn(" }")
+    end
+  end
+
+  class SigParam
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print("#{name}: #{type}")
+    end
+  end
+
+  class TStructField
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      case self
+      when TStructProp
+        v.printt("prop")
+      when TStructConst
+        v.printt("const")
+      end
+      v.print(" :#{name}, #{type}")
+      default = self.default
+      v.print(", default: #{default}") if default
+      v.printn
+    end
+  end
+
+  class TEnumBlock
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      v.printl("enums do")
+      v.indent
+      names.each do |name|
+        v.printl("#{name} = new")
+      end
+      v.dedent
+      v.printl("end")
+    end
+  end
+
+  class TypeMember
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      v.printl("#{name} = #{value}")
+    end
+  end
+
+  class Helper
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      v.printl("#{name}!")
+    end
+  end
+
+  class Group
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.printn unless v.previous_node.nil?
+      v.visit_all(nodes)
+    end
+  end
+
+  class VisibilityGroup
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.in_visibility_group = true
+      v.printn unless v.previous_node.nil?
+      case visibility
+      when Visibility::Protected, Visibility::Private
+        v.visit(visibility)
+        v.printn
+      end
+      v.visit_all(nodes)
+      v.in_visibility_group = false
+    end
+  end
+end