rbi 0.0.6 → 0.0.10

data/lib/rbi/printer.rb

@@ -11,14 +11,28 @@ module RBI
     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)
+    sig { returns(Integer) }
+    attr_reader :current_indent
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :max_line_length
+
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer)
+      ).void
+    end
+    def initialize(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
       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))
+      @max_line_length = max_line_length
     end
 
     # Printing
@@ -123,19 +137,35 @@ module RBI
     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)
+    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).returns(String) }
-    def string(indent: 0, print_locs: false)
+    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)
+      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
@@ -171,7 +201,7 @@ module RBI
     end
   end
 
-  class EmptyComment
+  class BlankLine
     extend T::Sig
 
     sig { override.params(v: Printer).void }
@@ -201,8 +231,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -295,8 +324,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -309,8 +337,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.visit_all(comments)
       sigs.each { |sig| v.visit(sig) }
@@ -346,8 +373,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.visit_all(comments)
       v.visit_all(sigs)
@@ -521,8 +547,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -543,8 +568,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -552,72 +576,65 @@ module RBI
     end
   end
 
-  class Sig
+  class Send
     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
-      if oneline?
-        v.printt("sig { ")
-      else
-        v.printl("sig do")
-        v.indent
-      end
-      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
+      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
-        v.print(").")
       end
-      unless params.empty?
-        if inline_params?
-          v.print("params(")
-          params.each_with_index do |param, index|
-            v.print(", ") if index > 0
-            v.visit(param)
-          end
-          v.print(").")
+      v.printn
+    end
+  end
+
+  class Arg
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print(value)
+    end
+  end
+
+  class KwArg
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print(keyword)
+      v.print(": ")
+      v.print(value)
+    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
+      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
-          v.printl("params(")
-          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|
-              if cindex == 0
-                v.print(" ")
-              else
-                param.print_comment_leading_space(v, last: pindex == params.size - 1)
-              end
-              v.print("# #{comment}")
-            end
-            v.printn
-          end
-          v.dedent
-          v.printt(").")
+          print_as_block(v)
         end
-      end
-      if return_type && return_type != "void"
-        v.print("returns(#{return_type})")
-      else
-        v.print("void")
-      end
-      if checked
-        v.print(".checked(:#{checked})")
-      end
-      if oneline?
-        v.printn(" }")
       else
-        v.printn
-        v.dedent
-        v.printl("end")
+        print_as_block(v)
       end
     end
 
@@ -630,6 +647,90 @@ module RBI
     def inline_params?
       params.all? { |p| p.comments.empty? }
     end
+
+    private
+
+    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
+    end
+
+    sig { params(v: Printer).void }
+    def print_as_line(v)
+      v.printt("sig { ")
+      sig_modifiers.each do |modifier|
+        v.print("#{modifier}.")
+      end
+      unless params.empty?
+        v.print("params(")
+        params.each_with_index do |param, index|
+          v.print(", ") if index > 0
+          v.visit(param)
+        end
+        v.print(").")
+      end
+      if return_type && return_type != "void"
+        v.print("returns(#{return_type})")
+      else
+        v.print("void")
+      end
+      v.printn(" }")
+    end
+
+    sig { params(v: Printer).void }
+    def print_as_block(v)
+      modifiers = sig_modifiers
+
+      v.printl("sig do")
+      v.indent
+      if modifiers.any?
+        v.printl(T.must(modifiers.first))
+        v.indent
+        modifiers[1..]&.each do |modifier|
+          v.printl(".#{modifier}")
+        end
+      end
+
+      if params.any?
+        v.printt
+        v.print(".") if modifiers.any?
+        v.printn("params(")
+        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|
+            if cindex == 0
+              v.print(" ")
+            else
+              param.print_comment_leading_space(v, last: pindex == params.size - 1)
+            end
+            v.print("# #{comment}")
+          end
+          v.printn
+        end
+        v.dedent
+        v.printt(")")
+      end
+      v.printt if params.empty?
+      v.print(".") if modifiers.any? || params.any?
+      if return_type && return_type != "void"
+        v.print("returns(#{return_type})")
+      else
+        v.print("void")
+      end
+      v.printn
+      v.dedent
+      v.dedent if modifiers.any?
+      v.printl("end")
+    end
   end
 
   class SigParam
@@ -659,8 +760,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -699,8 +799,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -713,8 +812,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -753,4 +851,17 @@ module RBI
       false
     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} }")
+    end
+  end
 end

data/lib/rbi/rewriters/annotate.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    class Annotate < Visitor
+      extend T::Sig
+
+      sig { params(annotation: String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+      def initialize(annotation, annotate_scopes: false, annotate_properties: false)
+        super()
+        @annotation = annotation
+        @annotate_scopes = annotate_scopes
+        @annotate_properties = annotate_properties
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Scope
+          annotate_node(node) if @annotate_scopes || root?(node)
+        when Const, Attr, Method, TStructField, TypeMember
+          annotate_node(node) if @annotate_properties
+        end
+        visit_all(node.nodes) if node.is_a?(Tree)
+      end
+
+      private
+
+      sig { params(node: NodeWithComments).void }
+      def annotate_node(node)
+        return if node.annotations.one?(@annotation)
+        node.comments << Comment.new("@#{@annotation}")
+      end
+
+      sig { params(node: Node).returns(T::Boolean) }
+      def root?(node)
+        parent = node.parent_tree
+        parent.is_a?(Tree) && parent.parent_tree.nil?
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { params(annotation: String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+    def annotate!(annotation, annotate_scopes: false, annotate_properties: false)
+      visitor = Rewriters::Annotate.new(
+        annotation,
+        annotate_scopes: annotate_scopes,
+        annotate_properties: annotate_properties
+      )
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/deannotate.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    class Deannotate < Visitor
+      extend T::Sig
+
+      sig { params(annotation: String).void }
+      def initialize(annotation)
+        super()
+        @annotation = annotation
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Scope, Const, Attr, Method, TStructField, TypeMember
+          deannotate_node(node)
+        end
+        visit_all(node.nodes) if node.is_a?(Tree)
+      end
+
+      private
+
+      sig { params(node: NodeWithComments).void }
+      def deannotate_node(node)
+        return unless node.annotations.one?(@annotation)
+        node.comments.reject! do |comment|
+          comment.text == "@#{@annotation}"
+        end
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { params(annotation: String).void }
+    def deannotate!(annotation)
+      visitor = Rewriters::Deannotate.new(annotation)
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/group_nodes.rb

@@ -49,12 +49,18 @@ module RBI
       case self
       when Include, Extend
         Group::Kind::Mixins
+      when RequiresAncestor
+        Group::Kind::RequiredAncestors
       when Helper
         Group::Kind::Helpers
       when TypeMember
         Group::Kind::TypeMembers
       when MixesInClassMethods
         Group::Kind::MixesInClassMethods
+      when Send
+        Group::Kind::Sends
+      when Attr
+        Group::Kind::Attrs
       when TStructField
         Group::Kind::TStructFields
       when TEnumBlock
@@ -67,6 +73,8 @@ module RBI
         else
           Group::Kind::Methods
         end
+      when SingletonClass
+        Group::Kind::SingletonClasses
       when Scope, Const
         Group::Kind::Consts
       else
@@ -90,13 +98,17 @@ module RBI
     class Kind < T::Enum
       enums do
         Mixins              = new
+        RequiredAncestors   = new
         Helpers             = new
         TypeMembers         = new
         MixesInClassMethods = new
+        Sends               = new
+        Attrs               = new
         TStructFields       = new
         TEnums              = new
         Inits               = new
         Methods             = new
+        SingletonClasses    = new
         Consts              = new
       end
     end

data/lib/rbi/rewriters/merge_trees.rb

@@ -47,7 +47,7 @@ module RBI
         end
       end
 
-      sig { params(left: Tree, right: Tree, left_name: String, right_name: String, keep: Keep).returns(Tree) }
+      sig { params(left: Tree, right: Tree, left_name: String, right_name: String, keep: Keep).returns(MergeTree) }
       def self.merge_trees(left, right, left_name: "left", right_name: "right", keep: Keep::NONE)
         left.nest_singleton_methods!
         right.nest_singleton_methods!
@@ -59,7 +59,7 @@ module RBI
         tree
       end
 
-      sig { returns(Tree) }
+      sig { returns(MergeTree) }
       attr_reader :tree
 
       sig { params(left_name: String, right_name: String, keep: Keep).void }
@@ -67,15 +67,15 @@ module RBI
         @left_name = left_name
         @right_name = right_name
         @keep = keep
-        @tree = T.let(Tree.new, Tree)
+        @tree = T.let(MergeTree.new, MergeTree)
         @scope_stack = T.let([@tree], T::Array[Tree])
       end
 
-      sig { params(tree: Tree).returns(T::Array[Conflict]) }
+      sig { params(tree: Tree).void }
       def merge(tree)
         v = TreeMerger.new(@tree, left_name: @left_name, right_name: @right_name, keep: @keep)
         v.visit(tree)
-        v.conflicts
+        @tree.conflicts.concat(v.conflicts)
       end
 
       # Used for logging / error displaying purpose
@@ -314,9 +314,31 @@ module RBI
   class Tree
     extend T::Sig
 
-    sig { params(other: Tree).returns(Tree) }
-    def merge(other)
-      Rewriters::Merge.merge_trees(self, other)
+    sig { params(other: Tree, left_name: String, right_name: String, keep: Rewriters::Merge::Keep).returns(MergeTree) }
+    def merge(other, left_name: "left", right_name: "right", keep: Rewriters::Merge::Keep::NONE)
+      Rewriters::Merge.merge_trees(self, other, left_name: left_name, right_name: right_name, keep: keep)
+    end
+  end
+
+  # A tree that _might_ contain conflicts
+  class MergeTree < Tree
+    extend T::Sig
+
+    sig { returns(T::Array[Rewriters::Merge::Conflict]) }
+    attr_reader :conflicts
+
+    sig do
+      params(
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        conflicts: T::Array[Rewriters::Merge::Conflict],
+        block: T.nilable(T.proc.params(node: Tree).void)
+      ).void
+    end
+    def initialize(loc: nil, comments: [], conflicts: [], &block)
+      super(loc: loc, comments: comments)
+      @conflicts = conflicts
+      block&.call(self)
     end
   end
 
@@ -490,6 +512,15 @@ module RBI
     end
   end
 
+  class Send
+    extend T::Sig
+
+    sig { override.params(other: Node).returns(T::Boolean) }
+    def compatible_with?(other)
+      other.is_a?(Send) && method == other.method && args == other.args
+    end
+  end
+
   class TStructField
     extend T::Sig