rbi 0.1.13 → 0.1.14

data/lib/rbi/printer.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 module RBI
+  class PrinterError < Error; end
+
   class Printer < Visitor
     extend T::Sig
 
@@ -74,18 +76,6 @@ module RBI
       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
@@ -96,783 +86,695 @@ module RBI
       end
       @previous_node = previous_node
     end
-  end
-
-  class File
-    extend T::Sig
 
-    sig { params(v: Printer).void }
-    def accept_printer(v)
-      strictness = self.strictness
+    sig { override.params(file: File).void }
+    def visit_file(file)
+      strictness = file.strictness
       if strictness
-        v.printl("# typed: #{strictness}")
+        printl("# typed: #{strictness}")
       end
-      unless comments.empty?
-        v.printn if strictness
-        v.visit_all(comments)
+      unless file.comments.empty?
+        printn if strictness
+        visit_all(file.comments)
       end
 
-      unless root.empty? && root.comments.empty?
-        v.printn if strictness || !comments.empty?
-        v.visit(root)
+      unless file.root.empty? && file.root.comments.empty?
+        printn if strictness || !file.comments.empty?
+        visit(file.root)
       end
     end
 
-    sig do
-      params(
-        out: T.any(IO, StringIO),
-        indent: Integer,
-        print_locs: T::Boolean,
-        max_line_length: T.nilable(Integer),
-      ).void
-    end
-    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
-      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
-      p.visit_file(self)
-    end
-
-    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
-    def string(indent: 0, print_locs: false, max_line_length: nil)
-      out = StringIO.new
-      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
-      out.string
-    end
-  end
-
-  class Node
-    extend T::Sig
-
-    sig { abstract.params(v: Printer).void }
-    def accept_printer(v); end
-
-    sig do
-      params(
-        out: T.any(IO, StringIO),
-        indent: Integer,
-        print_locs: T::Boolean,
-        max_line_length: T.nilable(Integer),
-      ).void
-    end
-    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
-      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
-      p.visit(self)
-    end
-
-    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
-    def string(indent: 0, print_locs: false, max_line_length: nil)
-      out = StringIO.new
-      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
-      out.string
-    end
-
-    sig { params(v: Printer).void }
-    def print_blank_line_before(v)
-      previous_node = v.previous_node
-      return unless previous_node
-      return if previous_node.is_a?(BlankLine)
-      return if previous_node.oneline? && oneline?
-
-      v.printn
-    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
+    private
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      lines = text.lines
+    sig { override.params(node: Comment).void }
+    def visit_comment(node)
+      lines = node.text.lines
 
       if lines.empty?
-        v.printl("#")
+        printl("#")
       end
 
       lines.each do |line|
         text = line.rstrip
-        v.printt("#")
-        v.print(" #{text}") unless text.empty?
-        v.printn
+        printt("#")
+        print(" #{text}") unless text.empty?
+        printn
       end
     end
-  end
 
-  class BlankLine
-    extend T::Sig
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.printn
+    sig { override.params(node: BlankLine).void }
+    def visit_blank_line(node)
+      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)
+    sig { override.params(node: Tree).void }
+    def visit_tree(node)
+      visit_all(node.comments)
+      printn if !node.comments.empty? && !node.empty?
+      visit_all(node.nodes)
     end
 
-    sig { override.returns(T::Boolean) }
-    def oneline?
-      comments.empty? && empty?
+    sig { override.params(node: Module).void }
+    def visit_module(node)
+      visit_scope(node)
     end
-  end
-
-  class Scope
-    extend T::Sig
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
 
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-
-      print_header(v)
-      print_body(v)
+    sig { override.params(node: Class).void }
+    def visit_class(node)
+      visit_scope(node)
     end
 
-    sig { abstract.params(v: Printer).void }
-    def print_header(v); end
+    sig { override.params(node: Struct).void }
+    def visit_struct(node)
+      visit_scope(node)
+    end
 
-    sig { params(v: Printer).void }
-    def print_body(v)
-      unless empty?
-        v.indent
-        v.visit_all(nodes)
-        v.dedent
-        v.printl("end")
-      end
+    sig { override.params(node: SingletonClass).void }
+    def visit_singleton_class(node)
+      visit_scope(node)
     end
-  end
 
-  class Module
-    extend T::Sig
+    sig { params(node: Scope).void }
+    def visit_scope(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def print_header(v)
-      v.printt("module #{name}")
-      if empty?
-        v.printn("; end")
-      else
-        v.printn
-      end
+      visit_scope_header(node)
+      visit_scope_body(node)
     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")
+    sig { params(node: Scope).void }
+    def visit_scope_header(node)
+      case node
+      when Module
+        printt("module #{node.name}")
+      when Class
+        printt("class #{node.name}")
+        superclass = node.superclass_name
+        print(" < #{superclass}") if superclass
+      when Struct
+        printt("#{node.name} = ::Struct.new")
+        if !node.members.empty? || node.keyword_init
+          print("(")
+          args = node.members.map { |member| ":#{member}" }
+          args << "keyword_init: true" if node.keyword_init
+          print(args.join(", "))
+          print(")")
+        end
+      when SingletonClass
+        printt("class << self")
+      when TStruct
+        printt("class #{node.name} < T::Struct")
+      when TEnum
+        printt("class #{node.name} < T::Enum")
       else
-        v.printn
+        raise PrinterError, "Unhandled node: #{node.class}"
       end
+      if node.empty? && !node.is_a?(Struct)
+        print("; end")
+      elsif !node.empty? && node.is_a?(Struct)
+        print(" do")
+      end
+      printn
     end
-  end
 
-  class Struct
-    extend T::Sig
+    sig { params(node: Scope).void }
+    def visit_scope_body(node)
+      return if node.empty?
 
-    sig { override.params(v: Printer).void }
-    def print_header(v)
-      v.printt("#{name} = ::Struct.new")
-      if !members.empty? || keyword_init
-        v.print("(")
-        args = members.map { |member| ":#{member}" }
-        args << "keyword_init: true" if keyword_init
-        v.print(args.join(", "))
-        v.print(")")
-      end
-      if empty?
-        v.printn
-      else
-        v.printn(" do")
-      end
+      indent
+      visit_all(node.nodes)
+      dedent
+      printl("end")
     end
-  end
 
-  class SingletonClass
-    extend T::Sig
+    sig { override.params(node: Const).void }
+    def visit_const(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def print_header(v)
-      v.printt("class << self")
-      if empty?
-        v.printn("; end")
-      else
-        v.printn
-      end
+      printl("#{node.name} = #{node.value}")
     end
-  end
 
-  class Const
-    extend T::Sig
+    sig { override.params(node: AttrAccessor).void }
+    def visit_attr_accessor(node)
+      visit_attr(node)
+    end
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
+    sig { override.params(node: AttrReader).void }
+    def visit_attr_reader(node)
+      visit_attr(node)
+    end
 
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-      v.printl("#{name} = #{value}")
+    sig { override.params(node: AttrWriter).void }
+    def visit_attr_writer(node)
+      visit_attr(node)
     end
-  end
 
-  class Attr
-    extend T::Sig
+    sig { params(node: Attr).void }
+    def visit_attr(node)
+      print_blank_line_before(node)
+
+      visit_all(node.comments)
+      node.sigs.each { |sig| visit(sig) }
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
-
-      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.public?
-        v.print(visibility.visibility.to_s)
-        v.print(" ")
+      print_loc(node)
+      printt
+      unless in_visibility_group || node.visibility.public?
+        self.print(node.visibility.visibility.to_s)
+        print(" ")
       end
-      case self
+      case node
       when AttrAccessor
-        v.print("attr_accessor")
+        print("attr_accessor")
       when AttrReader
-        v.print("attr_reader")
+        print("attr_reader")
       when AttrWriter
-        v.print("attr_writer")
+        print("attr_writer")
       end
-      unless names.empty?
-        v.print(" ")
-        v.print(names.map { |name| ":#{name}" }.join(", "))
+      unless node.names.empty?
+        print(" ")
+        print(node.names.map { |name| ":#{name}" }.join(", "))
       end
-      v.printn
+      printn
     end
 
-    sig { override.returns(T::Boolean) }
-    def oneline?
-      comments.empty? && sigs.empty?
-    end
-  end
-
-  class Method
-    extend T::Sig
+    sig { override.params(node: Method).void }
+    def visit_method(node)
+      print_blank_line_before(node)
+      visit_all(node.comments)
+      visit_all(node.sigs)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
-
-      v.visit_all(comments)
-      v.visit_all(sigs)
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.printt
-      unless v.in_visibility_group || visibility.public?
-        v.print(visibility.visibility.to_s)
-        v.print(" ")
+      print_loc(node)
+      printt
+      unless in_visibility_group || node.visibility.public?
+        self.print(node.visibility.visibility.to_s)
+        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)
+      print("def ")
+      print("self.") if node.is_singleton
+      print(node.name)
+      unless node.params.empty?
+        print("(")
+        if node.params.all? { |p| p.comments.empty? }
+          node.params.each_with_index do |param, index|
+            print(", ") if index > 0
+            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_lines.each_with_index do |comment, cindex|
+          printn
+          indent
+          node.params.each_with_index do |param, pindex|
+            printt
+            visit(param)
+            print(",") if pindex < node.params.size - 1
+
+            comment_lines = param.comments.flat_map { |comment| comment.text.lines.map(&:rstrip) }
+            comment_lines.each_with_index do |comment, cindex|
               if cindex > 0
-                param.print_comment_leading_space(v, last: pindex == params.size - 1)
+                print_param_comment_leading_space(param, last: pindex == node.params.size - 1)
               else
-                v.print(" ")
+                print(" ")
               end
-              v.print("# #{comment}")
+              print("# #{comment}")
             end
-            v.printn
+            printn
           end
-          v.dedent
+          dedent
         end
-        v.print(")")
+        print(")")
       end
-      v.print("; end")
-      v.printn
+      print("; end")
+      printn
     end
 
-    sig { override.returns(T::Boolean) }
-    def oneline?
-      comments.empty? && sigs.empty? && inline_params?
+    sig { override.params(node: ReqParam).void }
+    def visit_req_param(node)
+      print(node.name)
     end
 
-    sig { returns(T::Boolean) }
-    def inline_params?
-      params.all? { |p| p.comments.empty? }
+    sig { override.params(node: OptParam).void }
+    def visit_opt_param(node)
+      print("#{node.name} = #{node.value}")
     end
-  end
 
-  class Param
-    extend T::Sig
+    sig { override.params(node: RestParam).void }
+    def visit_rest_param(node)
+      print("*#{node.name}")
+    end
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print(name.to_s)
+    sig { override.params(node: KwParam).void }
+    def visit_kw_param(node)
+      print("#{node.name}:")
     end
 
-    sig { params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      v.printn
-      v.printt
-      v.print(" " * (name.size + 1))
-      v.print(" ") unless last
+    sig { override.params(node: KwOptParam).void }
+    def visit_kw_opt_param(node)
+      print("#{node.name}: #{node.value}")
     end
 
-    sig { returns(T::Array[String]) }
-    def comments_lines
-      comments.flat_map { |comment| comment.text.lines.map(&:rstrip) }
+    sig { override.params(node: KwRestParam).void }
+    def visit_kw_rest_param(node)
+      print("**#{node.name}")
     end
-  end
 
-  class OptParam
-    extend T::Sig
+    sig { override.params(node: BlockParam).void }
+    def visit_block_param(node)
+      print("&#{node.name}")
+    end
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print("#{name} = #{value}")
+    sig { override.params(node: Include).void }
+    def visit_include(node)
+      visit_mixin(node)
     end
 
-    sig { override.params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      super
-      v.print(" " * (value.size + 3))
+    sig { override.params(node: Extend).void }
+    def visit_extend(node)
+      visit_mixin(node)
     end
-  end
 
-  class RestParam
-    extend T::Sig
+    sig { params(node: Mixin).void }
+    def visit_mixin(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print("*#{name}")
+      case node
+      when Include
+        printt("include")
+      when Extend
+        printt("extend")
+      when MixesInClassMethods
+        printt("mixes_in_class_methods")
+      end
+      printn(" #{node.names.join(", ")}")
     end
 
-    sig { override.params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      super
-      v.print(" ")
+    sig { override.params(node: Public).void }
+    def visit_public(node)
+      visit_visibility(node)
     end
-  end
-
-  class KwParam
-    extend T::Sig
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print("#{name}:")
+    sig { override.params(node: Protected).void }
+    def visit_protected(node)
+      visit_visibility(node)
     end
 
-    sig { override.params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      super
-      v.print(" ")
+    sig { override.params(node: Private).void }
+    def visit_private(node)
+      visit_visibility(node)
     end
-  end
 
-  class KwOptParam
-    extend T::Sig
+    sig { params(node: Visibility).void }
+    def visit_visibility(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print("#{name}: #{value}")
+      printl(node.visibility.to_s)
     end
 
-    sig { override.params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      super
-      v.print(" " * (value.size + 2))
-    end
-  end
+    sig { override.params(node: Send).void }
+    def visit_send(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-  class KwRestParam
-    extend T::Sig
+      printt(node.method)
+      unless node.args.empty?
+        print(" ")
+        node.args.each_with_index do |arg, index|
+          visit(arg)
+          print(", ") if index < node.args.size - 1
+        end
+      end
+      printn
+    end
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print("**#{name}")
+    sig { override.params(node: Arg).void }
+    def visit_arg(node)
+      print(node.value)
     end
 
-    sig { override.params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      super
-      v.print("  ")
+    sig { override.params(node: KwArg).void }
+    def visit_kw_arg(node)
+      print("#{node.keyword}: #{node.value}")
     end
-  end
 
-  class BlockParam
-    extend T::Sig
+    sig { override.params(node: Sig).void }
+    def visit_sig(node)
+      print_loc(node)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print("&#{name}")
+      max_line_length = self.max_line_length
+      if oneline?(node) && max_line_length.nil?
+        print_sig_as_line(node)
+      elsif max_line_length
+        line = node.string(indent: current_indent)
+        if line.length <= max_line_length
+          print(line)
+        else
+          print_sig_as_block(node)
+        end
+      else
+        print_sig_as_block(node)
+      end
     end
 
-    sig { override.params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      super
-      v.print(" ")
+    sig { override.params(node: SigParam).void }
+    def visit_sig_param(node)
+      print("#{node.name}: #{node.type}")
     end
-  end
 
-  class Mixin
-    extend T::Sig
+    sig { override.params(node: TStruct).void }
+    def visit_tstruct(node)
+      visit_scope(node)
+    end
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
+    sig { override.params(node: TStructConst).void }
+    def visit_tstruct_const(node)
+      visit_t_struct_field(node)
+    end
 
-      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(", ")}")
+    sig { override.params(node: TStructProp).void }
+    def visit_tstruct_prop(node)
+      visit_t_struct_field(node)
     end
-  end
 
-  class Visibility
-    extend T::Sig
+    sig { params(node: TStructField).void }
+    def visit_t_struct_field(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
+      case node
+      when TStructProp
+        printt("prop")
+      when TStructConst
+        printt("const")
+      end
+      print(" :#{node.name}, #{node.type}")
+      default = node.default
+      print(", default: #{default}") if default
+      printn
+    end
 
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-      v.printl(visibility.to_s)
+    sig { override.params(node: TEnum).void }
+    def visit_tenum(node)
+      visit_scope(node)
     end
-  end
 
-  class Send
-    extend T::Sig
+    sig { override.params(node: TEnumBlock).void }
+    def visit_tenum_block(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
-
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-      v.printt(method)
-      unless args.empty?
-        v.print(" ")
-        args.each_with_index do |arg, index|
-          v.visit(arg)
-          v.print(", ") if index < args.size - 1
-        end
+      printl("enums do")
+      indent
+      node.names.each do |name|
+        printl("#{name} = new")
       end
-      v.printn
+      dedent
+      printl("end")
     end
-  end
 
-  class Arg
-    extend T::Sig
+    sig { override.params(node: TypeMember).void }
+    def visit_type_member(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print(value)
+      printl("#{node.name} = #{node.value}")
     end
-  end
 
-  class KwArg
-    extend T::Sig
+    sig { override.params(node: Helper).void }
+    def visit_helper(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print(keyword)
-      v.print(": ")
-      v.print(value)
+      printl("#{node.name}!")
     end
-  end
 
-  class Sig
-    extend T::Sig
+    sig { override.params(node: MixesInClassMethods).void }
+    def visit_mixes_in_class_methods(node)
+      visit_mixin(node)
+    end
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.printl("# #{loc}") if loc && v.print_locs
-      max_line_length = v.max_line_length
-      if oneline? && max_line_length.nil?
-        print_as_line(v)
-      elsif max_line_length
-        line = string(indent: v.current_indent)
-        if line.length <= max_line_length
-          v.print(line)
-        else
-          print_as_block(v)
-        end
+    sig { override.params(node: Group).void }
+    def visit_group(node)
+      printn unless previous_node.nil?
+      visit_all(node.nodes)
+    end
+
+    sig { override.params(node: VisibilityGroup).void }
+    def visit_visibility_group(node)
+      self.in_visibility_group = true
+      if node.visibility.public?
+        printn unless previous_node.nil?
       else
-        print_as_block(v)
+        visit(node.visibility)
+        printn
       end
+      visit_all(node.nodes)
+      self.in_visibility_group = false
     end
 
-    sig { override.returns(T::Boolean) }
-    def oneline?
-      inline_params?
+    sig { override.params(node: RequiresAncestor).void }
+    def visit_requires_ancestor(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
+
+      printl("requires_ancestor { #{node.name} }")
     end
 
-    sig { returns(T::Boolean) }
-    def inline_params?
-      params.all? { |p| p.comments.empty? }
+    sig { override.params(node: ConflictTree).void }
+    def visit_conflict_tree(node)
+      printl("<<<<<<< #{node.left_name}")
+      visit(node.left)
+      printl("=======")
+      visit(node.right)
+      printl(">>>>>>> #{node.right_name}")
     end
 
-    private
+    sig { override.params(node: ScopeConflict).void }
+    def visit_scope_conflict(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
 
-    sig { returns(T::Array[String]) }
-    def sig_modifiers
-      modifiers = T.let([], T::Array[String])
-      modifiers << "abstract" if is_abstract
-      modifiers << "override" if is_override
-      modifiers << "overridable" if is_overridable
-      modifiers << "type_parameters(#{type_params.map { |type| ":#{type}" }.join(", ")})" if type_params.any?
-      modifiers << "checked(:#{checked})" if checked
-      modifiers
+      printl("<<<<<<< #{node.left_name}")
+      visit_scope_header(node.left)
+      printl("=======")
+      visit_scope_header(node.right)
+      printl(">>>>>>> #{node.right_name}")
+      visit_scope_body(node.left)
+    end
+
+    sig { params(node: Node).void }
+    def print_blank_line_before(node)
+      previous_node = self.previous_node
+      return unless previous_node
+      return if previous_node.is_a?(BlankLine)
+      return if oneline?(previous_node) && oneline?(node)
+
+      printn
+    end
+
+    sig { params(node: Node).void }
+    def print_loc(node)
+      loc = node.loc
+      printl("# #{loc}") if loc && print_locs
     end
 
-    sig { params(v: Printer).void }
-    def print_as_line(v)
-      v.printt("sig")
-      v.print("(:final)") if is_final
-      v.print(" { ")
-      sig_modifiers.each do |modifier|
-        v.print("#{modifier}.")
+    sig { params(node: Param, last: T::Boolean).void }
+    def print_param_comment_leading_space(node, last:)
+      printn
+      printt
+      print(" " * (node.name.size + 1))
+      print(" ") unless last
+      case node
+      when OptParam
+        print(" " * (node.value.size + 3))
+      when RestParam, KwParam, BlockParam
+        print(" ")
+      when KwRestParam
+        print("  ")
+      when KwOptParam
+        print(" " * (node.value.size + 2))
       end
-      unless params.empty?
-        v.print("params(")
-        params.each_with_index do |param, index|
-          v.print(", ") if index > 0
-          v.visit(param)
+    end
+
+    sig { params(node: SigParam, last: T::Boolean).void }
+    def print_sig_param_comment_leading_space(node, last:)
+      printn
+      printt
+      print(" " * (node.name.size + node.type.size + 3))
+      print(" ") unless last
+    end
+
+    sig { params(node: Node).returns(T::Boolean) }
+    def oneline?(node)
+      case node
+      when ScopeConflict
+        oneline?(node.left)
+      when Tree
+        node.comments.empty? && node.empty?
+      when Attr
+        node.comments.empty? && node.sigs.empty?
+      when Method
+        node.comments.empty? && node.sigs.empty? && node.params.all? { |p| p.comments.empty? }
+      when Sig
+        node.params.all? { |p| p.comments.empty? }
+      when NodeWithComments
+        node.comments.empty?
+      when VisibilityGroup
+        false
+      else
+        true
+      end
+    end
+
+    sig { params(node: Sig).void }
+    def print_sig_as_line(node)
+      printt("sig")
+      print("(:final)") if node.is_final
+      print(" { ")
+      sig_modifiers(node).each do |modifier|
+        print("#{modifier}.")
+      end
+      unless node.params.empty?
+        print("params(")
+        node.params.each_with_index do |param, index|
+          print(", ") if index > 0
+          visit(param)
         end
-        v.print(").")
+        print(").")
       end
-      if return_type && return_type != "void"
-        v.print("returns(#{return_type})")
+      return_type = node.return_type
+      if node.return_type && node.return_type != "void"
+        print("returns(#{return_type})")
       else
-        v.print("void")
+        print("void")
       end
-      v.printn(" }")
+      printn(" }")
     end
 
-    sig { params(v: Printer).void }
-    def print_as_block(v)
-      modifiers = sig_modifiers
+    sig { params(node: Sig).void }
+    def print_sig_as_block(node)
+      modifiers = sig_modifiers(node)
 
-      v.printl("sig do")
-      v.indent
+      printt("sig")
+      print("(:final)") if node.is_final
+      printn(" do")
+      indent
       if modifiers.any?
-        v.printl(T.must(modifiers.first))
-        v.indent
+        printl(T.must(modifiers.first))
+        indent
         modifiers[1..]&.each do |modifier|
-          v.printl(".#{modifier}")
+          printl(".#{modifier}")
         end
       end
 
+      params = node.params
       if params.any?
-        v.printt
-        v.print(".") if modifiers.any?
-        v.printn("params(")
-        v.indent
+        printt
+        print(".") if modifiers.any?
+        printn("params(")
+        indent
         params.each_with_index do |param, pindex|
-          v.printt
-          v.visit(param)
-          v.print(",") if pindex < params.size - 1
-          param.comments_lines.each_with_index do |comment, cindex|
+          printt
+          visit(param)
+          print(",") if pindex < params.size - 1
+
+          comment_lines = param.comments.flat_map { |comment| comment.text.lines.map(&:rstrip) }
+          comment_lines.each_with_index do |comment, cindex|
             if cindex == 0
-              v.print(" ")
+              print(" ")
             else
-              param.print_comment_leading_space(v, last: pindex == params.size - 1)
+              print_sig_param_comment_leading_space(param, last: pindex == params.size - 1)
             end
-            v.print("# #{comment}")
+            print("# #{comment}")
           end
-          v.printn
+          printn
         end
-        v.dedent
-        v.printt(")")
+        dedent
+        printt(")")
       end
-      v.printt if params.empty?
-      v.print(".") if modifiers.any? || params.any?
+      printt if params.empty?
+      print(".") if modifiers.any? || params.any?
+
+      return_type = node.return_type
       if return_type && return_type != "void"
-        v.print("returns(#{return_type})")
+        print("returns(#{return_type})")
       else
-        v.print("void")
+        print("void")
       end
-      v.printn
-      v.dedent
-      v.dedent if modifiers.any?
-      v.printl("end")
+      printn
+      dedent
+      dedent if modifiers.any?
+      printl("end")
     end
-  end
-
-  class SigParam
-    extend T::Sig
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.print("#{name}: #{type}")
-    end
-
-    sig { params(v: Printer, last: T::Boolean).void }
-    def print_comment_leading_space(v, last:)
-      v.printn
-      v.printt
-      v.print(" " * (name.size + type.size + 3))
-      v.print(" ") unless last
-    end
-
-    sig { returns(T::Array[String]) }
-    def comments_lines
-      comments.flat_map { |comment| comment.text.lines.map(&:rstrip) }
-    end
-  end
-
-  class TStructField
-    extend T::Sig
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
-
-      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")
+    sig { params(node: Sig).returns(T::Array[String]) }
+    def sig_modifiers(node)
+      modifiers = T.let([], T::Array[String])
+      modifiers << "abstract" if node.is_abstract
+      modifiers << "override" if node.is_override
+      modifiers << "overridable" if node.is_overridable
+      modifiers << "type_parameters(#{node.type_params.map { |type| ":#{type}" }.join(", ")})" if node.type_params.any?
+      modifiers << "checked(:#{node.checked})" if node.checked
+      modifiers
     end
   end
 
-  class TypeMember
+  class File
     extend T::Sig
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
-
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-      v.printl("#{name} = #{value}")
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer),
+      ).void
     end
-  end
-
-  class Helper
-    extend T::Sig
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
-
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-      v.printl("#{name}!")
+    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
+      p.visit_file(self)
     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)
+    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
+    def string(indent: 0, print_locs: false, max_line_length: nil)
+      out = StringIO.new
+      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
+      out.string
     end
   end
 
-  class VisibilityGroup
+  class Node
     extend T::Sig
 
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.in_visibility_group = true
-      if visibility.public?
-        v.printn unless v.previous_node.nil?
-      else
-        v.visit(visibility)
-        v.printn
-      end
-      v.visit_all(nodes)
-      v.in_visibility_group = false
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer),
+      ).void
     end
-
-    sig { override.returns(T::Boolean) }
-    def oneline?
-      false
+    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
+      p.visit(self)
     end
-  end
 
-  class RequiresAncestor
-    extend T::Sig
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      print_blank_line_before(v)
-
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-      v.printl("requires_ancestor { #{name} }")
+    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
+    def string(indent: 0, print_locs: false, max_line_length: nil)
+      out = StringIO.new
+      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
+      out.string
     end
   end
 end