rbi 0.0.2 → 0.0.3

data/lib/rbi/printer.rb

@@ -163,6 +163,15 @@ module RBI
     end
   end
 
+  class EmptyComment
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.printn
+    end
+  end
+
   class Tree
     extend T::Sig
 
@@ -238,6 +247,27 @@ module RBI
     end
   end
 
+  class Struct
+    extend T::Sig
+
+    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
+    end
+  end
+
   class SingletonClass
     extend T::Sig
 
@@ -278,7 +308,7 @@ module RBI
       sigs.each { |sig| v.visit(sig) }
       v.printl("# #{loc}") if loc && v.print_locs
       v.printt
-      unless v.in_visibility_group || visibility == Visibility::Public
+      unless v.in_visibility_group || visibility.public?
         v.print(visibility.visibility.to_s)
         v.print(" ")
       end
@@ -315,7 +345,7 @@ module RBI
       v.visit_all(sigs)
       v.printl("# #{loc}") if loc && v.print_locs
       v.printt
-      unless v.in_visibility_group || visibility == Visibility::Public
+      unless v.in_visibility_group || visibility.public?
         v.print(visibility.visibility.to_s)
         v.print(" ")
       end
@@ -338,7 +368,7 @@ module RBI
             v.print(",") if pindex < params.size - 1
             param.comments.each_with_index do |comment, cindex|
               if cindex > 0
-                param.print_comment_leading_space(v)
+                param.print_comment_leading_space(v, last: pindex == params.size - 1)
               else
                 v.print(" ")
               end
@@ -373,11 +403,12 @@ module RBI
       v.print(name.to_s)
     end
 
-    sig { params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       v.printn
       v.printt
-      v.print(" " * (name.size + 2))
+      v.print(" " * (name.size + 1))
+      v.print(" ") unless last
     end
   end
 
@@ -389,8 +420,8 @@ module RBI
       v.print("#{name} = #{value}")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print(" " * (value.size + 3))
     end
@@ -404,8 +435,8 @@ module RBI
       v.print("*#{name}")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print(" ")
     end
@@ -419,8 +450,8 @@ module RBI
       v.print("#{name}:")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print(" ")
     end
@@ -434,11 +465,9 @@ module RBI
       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))
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
+      super
       v.print(" " * (value.size + 2))
     end
   end
@@ -451,8 +480,8 @@ module RBI
       v.print("**#{name}")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print("  ")
     end
@@ -465,6 +494,12 @@ module RBI
     def accept_printer(v)
       v.print("&#{name}")
     end
+
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
+      super
+      v.print(" ")
+    end
   end
 
   class Mixin
@@ -494,7 +529,11 @@ 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?)
+
       v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
       v.printl(visibility.to_s)
     end
   end
@@ -505,7 +544,12 @@ module RBI
     sig { override.params(v: Printer).void }
     def accept_printer(v)
       v.printl("# #{loc}") if loc && v.print_locs
-      v.printt("sig { ")
+      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
@@ -518,12 +562,33 @@ module RBI
         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
+        if inline_params?
+          v.print("params(")
+          params.each_with_index do |param, index|
+            v.print(", ") if index > 0
+            v.visit(param)
+          end
+          v.print(").")
+        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.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.text.strip}")
+            end
+            v.printn
+          end
+          v.dedent
+          v.printt(").")
         end
-        v.print(").")
       end
       if return_type && return_type != "void"
         v.print("returns(#{return_type})")
@@ -533,7 +598,23 @@ module RBI
       if checked
         v.print(".checked(:#{checked})")
       end
-      v.printn(" }")
+      if oneline?
+        v.printn(" }")
+      else
+        v.printn
+        v.dedent
+        v.printl("end")
+      end
+    end
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      inline_params?
+    end
+
+    sig { returns(T::Boolean) }
+    def inline_params?
+      params.all? { |p| p.comments.empty? }
     end
   end
 
@@ -544,6 +625,14 @@ module RBI
     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
   end
 
   class TStructField
@@ -630,14 +719,19 @@ module RBI
     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
+      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
     end
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      false
+    end
   end
 end

data/lib/rbi/rewriters/add_sig_templates.rb

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    class AddSigTemplates < Visitor
+      extend T::Sig
+
+      sig { params(with_todo_comment: T::Boolean).void }
+      def initialize(with_todo_comment: true)
+        super()
+        @with_todo_comment = with_todo_comment
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Tree
+          visit_all(node.nodes)
+        when Attr
+          add_attr_sig(node)
+        when Method
+          add_method_sig(node)
+        end
+      end
+
+      private
+
+      sig { params(attr: Attr).void }
+      def add_attr_sig(attr)
+        return unless attr.sigs.empty?
+        return if attr.names.size > 1
+
+        params = []
+        params << SigParam.new(attr.names.first.to_s, "T.untyped") if attr.is_a?(AttrWriter)
+
+        attr.sigs << Sig.new(
+          params: params,
+          return_type: "T.untyped"
+        )
+        add_todo_comment(attr)
+      end
+
+      sig { params(method: Method).void }
+      def add_method_sig(method)
+        return unless method.sigs.empty?
+
+        method.sigs << Sig.new(
+          params: method.params.map { |param| SigParam.new(param.name, "T.untyped") },
+          return_type: "T.untyped"
+        )
+        add_todo_comment(method)
+      end
+
+      sig { params(node: NodeWithComments).void }
+      def add_todo_comment(node)
+        node.comments << Comment.new("TODO: fill in signature with appropriate type information") if @with_todo_comment
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { params(with_todo_comment: T::Boolean).void }
+    def add_sig_templates!(with_todo_comment: true)
+      visitor = Rewriters::AddSigTemplates.new(with_todo_comment: with_todo_comment)
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/merge_trees.rb

@@ -39,9 +39,17 @@ module RBI
     class Merge
       extend T::Sig
 
-      sig { params(left: Tree, right: Tree, left_name: String, right_name: String).returns(Tree) }
-      def self.merge_trees(left, right, left_name: "left", right_name: "right")
-        rewriter = Rewriters::Merge.new(left_name: left_name, right_name: right_name)
+      class Keep < ::T::Enum
+        enums do
+          NONE = new
+          LEFT = new
+          RIGHT = new
+        end
+      end
+
+      sig { params(left: Tree, right: Tree, left_name: String, right_name: String, keep: Keep).returns(Tree) }
+      def self.merge_trees(left, right, left_name: "left", right_name: "right", keep: Keep::NONE)
+        rewriter = Rewriters::Merge.new(left_name: left_name, right_name: right_name, keep: keep)
         rewriter.merge(left)
         rewriter.merge(right)
         tree = rewriter.tree
@@ -52,17 +60,18 @@ module RBI
       sig { returns(Tree) }
       attr_reader :tree
 
-      sig { params(left_name: String, right_name: String).void }
-      def initialize(left_name: "left", right_name: "right")
+      sig { params(left_name: String, right_name: String, keep: Keep).void }
+      def initialize(left_name: "left", right_name: "right", keep: Keep::NONE)
         @left_name = left_name
         @right_name = right_name
+        @keep = keep
         @tree = T.let(Tree.new, Tree)
         @scope_stack = T.let([@tree], T::Array[Tree])
       end
 
       sig { params(tree: Tree).returns(T::Array[Conflict]) }
       def merge(tree)
-        v = TreeMerger.new(@tree, left_name: @left_name, right_name: @right_name)
+        v = TreeMerger.new(@tree, left_name: @left_name, right_name: @right_name, keep: @keep)
         v.visit(tree)
         v.conflicts
       end
@@ -88,14 +97,15 @@ module RBI
         sig { returns(T::Array[Conflict]) }
         attr_reader :conflicts
 
-        sig { params(output: Tree, left_name: String, right_name: String).void }
-        def initialize(output, left_name: "left", right_name: "right")
+        sig { params(output: Tree, left_name: String, right_name: String, keep: Keep).void }
+        def initialize(output, left_name: "left", right_name: "right", keep: Keep::NONE)
           super()
           @tree = output
           @index = T.let(output.index, Index)
           @scope_stack = T.let([@tree], T::Array[Tree])
           @left_name = left_name
           @right_name = right_name
+          @keep = keep
           @conflicts = T.let([], T::Array[Conflict])
         end
 
@@ -110,6 +120,10 @@ module RBI
             if prev.is_a?(Scope)
               if node.compatible_with?(prev)
                 prev.merge_with(node)
+              elsif @keep == Keep::LEFT
+                # do nothing it's already merged
+              elsif @keep == Keep::RIGHT
+                prev = replace_scope_header(prev, node)
               else
                 make_conflict_scope(prev, node)
               end
@@ -129,6 +143,10 @@ module RBI
             if prev
               if node.compatible_with?(prev)
                 prev.merge_with(node)
+              elsif @keep == Keep::LEFT
+                # do nothing it's already merged
+              elsif @keep == Keep::RIGHT
+                prev.replace(node)
               else
                 make_conflict_tree(prev, node)
               end
@@ -175,6 +193,17 @@ module RBI
           end
           tree.right << right
         end
+
+        sig { params(left: Scope, right: Scope).returns(Scope) }
+        def replace_scope_header(left, right)
+          right_copy = right.dup_empty
+          left.replace(right_copy)
+          left.nodes.each do |node|
+            right_copy << node
+          end
+          @index.index(right_copy)
+          right_copy
+        end
       end
 
       # Merge adjacent conflict trees
@@ -300,6 +329,8 @@ module RBI
         Module.new(name, loc: loc, comments: comments)
       when Class
         Class.new(name, superclass_name: superclass_name, loc: loc, comments: comments)
+      when Struct
+        Struct.new(name, members: members, keyword_init: keyword_init, loc: loc, comments: comments)
       when SingletonClass
         SingletonClass.new(loc: loc, comments: comments)
       else
@@ -326,6 +357,15 @@ module RBI
     end
   end
 
+  class Struct
+    extend T::Sig
+
+    sig { override.params(other: Node).returns(T::Boolean) }
+    def compatible_with?(other)
+      other.is_a?(Struct) && members == other.members && keyword_init == other.keyword_init
+    end
+  end
+
   class Const
     extend T::Sig