rbi 0.1.14 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3705c571d4b2685e60fec1c0dc54435caed79ba988239006be0bf14757790c51
-  data.tar.gz: 4560dc122385781dd604cdc4ca57835caa22e3f29b2cafa5b7e2e468032c5923
+  metadata.gz: 8bcb914ddfe3208193a252f650ac6bcbc25c741efa183d28876ad1f0957cd24f
+  data.tar.gz: db2f129f6925c498e6112e43a7fc44b9a4a6aeb694cd18e97e64e3531bfe7ae4
 SHA512:
-  metadata.gz: 3f70d57182bed826c64ca53ed2d62a1da0aeb0dee1badbe774ed00c8bd505b8e40f00363c4ca069efef457649cff19ce6b2be595e6dca453e56456eb4580ca38
-  data.tar.gz: 5c60fedeeb8995f9e6ed4ef926f68870ed88021de20e60294e1aec97029c728f24d098a8d297ec967dbfc23c31788dbb30d82b8f925f1c95962df7772580c294
+  metadata.gz: 0def2a8d159eba09b59cbd403126a4b198687f018c65acec3d35cfa978d25da1bc97956ccb2d017d81ece08fe8e1f65e06b0ed4968b60fcb3b3e4b5cb497cdfe
+  data.tar.gz: 7f065932016677c397967f1dc16ca5115d8279ec65d00962e850496f616c16f76954e334611a66132cdeeea889866f5c41ffd2089ee5f9cdf473d77211cbfd80

data/Gemfile

@@ -14,5 +14,5 @@ group(:development, :test) do
   gem("rubocop-shopify", require: false)
   gem("rubocop-sorbet", require: false)
   gem("sorbet", ">= 0.5.9204", require: false)
-  gem("tapioca", require: false)
+  gem("tapioca", github: "Shopify/tapioca", branch: "at-bump-rbi", require: false)
 end

data/lib/rbi/formatter.rb

@@ -17,7 +17,7 @@ module RBI
         group_nodes: T::Boolean,
         max_line_length: T.nilable(Integer),
         nest_singleton_methods: T::Boolean,
-        nest_non_public_methods: T::Boolean,
+        nest_non_public_members: T::Boolean,
         sort_nodes: T::Boolean,
       ).void
     end
@@ -26,14 +26,14 @@ module RBI
       group_nodes: false,
       max_line_length: nil,
       nest_singleton_methods: false,
-      nest_non_public_methods: false,
+      nest_non_public_members: false,
       sort_nodes: false
     )
       @add_sig_templates = add_sig_templates
       @group_nodes = group_nodes
       @max_line_length = max_line_length
       @nest_singleton_methods = nest_singleton_methods
-      @nest_non_public_methods = nest_non_public_methods
+      @nest_non_public_members = nest_non_public_members
       @sort_nodes = sort_nodes
     end
 
@@ -52,7 +52,7 @@ module RBI
     def format_tree(tree)
       tree.add_sig_templates! if @add_sig_templates
       tree.nest_singleton_methods! if @nest_singleton_methods
-      tree.nest_non_public_methods! if @nest_non_public_methods
+      tree.nest_non_public_members! if @nest_non_public_members
       tree.group_nodes! if @group_nodes
       tree.sort_nodes! if @sort_nodes
     end

data/lib/rbi/model.rb

@@ -574,7 +574,7 @@ module RBI
     sig do
       params(
         params: T::Array[SigParam],
-        return_type: T.nilable(String),
+        return_type: T.any(String, Type),
         is_abstract: T::Boolean,
         is_override: T::Boolean,
         is_overridable: T::Boolean,
@@ -586,7 +586,7 @@ module RBI
     end
     def add_sig(
       params: [],
-      return_type: nil,
+      return_type: "void",
       is_abstract: false,
       is_override: false,
       is_overridable: false,
@@ -928,8 +928,10 @@ module RBI
       @visibility = visibility
     end
 
-    sig { params(other: Visibility).returns(T::Boolean) }
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
     def ==(other)
+      return false unless other.is_a?(Visibility)
+
       visibility == other.visibility
     end
 
@@ -1099,13 +1101,13 @@ module RBI
 
   # Sorbet's sigs
 
-  class Sig < Node
+  class Sig < NodeWithComments
     extend T::Sig
 
     sig { returns(T::Array[SigParam]) }
     attr_reader :params
 
-    sig { returns(T.nilable(String)) }
+    sig { returns(T.any(Type, String)) }
     attr_accessor :return_type
 
     sig { returns(T::Boolean) }
@@ -1120,7 +1122,7 @@ module RBI
     sig do
       params(
         params: T::Array[SigParam],
-        return_type: T.nilable(String),
+        return_type: T.any(Type, String),
         is_abstract: T::Boolean,
         is_override: T::Boolean,
         is_overridable: T::Boolean,
@@ -1128,12 +1130,13 @@ module RBI
         type_params: T::Array[String],
         checked: T.nilable(Symbol),
         loc: T.nilable(Loc),
+        comments: T::Array[Comment],
         block: T.nilable(T.proc.params(node: Sig).void),
       ).void
     end
     def initialize(
       params: [],
-      return_type: nil,
+      return_type: "void",
       is_abstract: false,
       is_override: false,
       is_overridable: false,
@@ -1141,9 +1144,10 @@ module RBI
       type_params: [],
       checked: nil,
       loc: nil,
+      comments: [],
       &block
     )
-      super(loc: loc)
+      super(loc: loc, comments: comments)
       @params = params
       @return_type = return_type
       @is_abstract = is_abstract
@@ -1160,7 +1164,7 @@ module RBI
       @params << param
     end
 
-    sig { params(name: String, type: String).void }
+    sig { params(name: String, type: T.any(Type, String)).void }
     def add_param(name, type)
       @params << SigParam.new(name, type)
     end
@@ -1169,7 +1173,7 @@ module RBI
     def ==(other)
       return false unless other.is_a?(Sig)
 
-      params == other.params && return_type == other.return_type && is_abstract == other.is_abstract &&
+      params == other.params && return_type.to_s == other.return_type.to_s && is_abstract == other.is_abstract &&
         is_override == other.is_override && is_overridable == other.is_overridable && is_final == other.is_final &&
         type_params == other.type_params && checked == other.checked
     end
@@ -1179,12 +1183,15 @@ module RBI
     extend T::Sig
 
     sig { returns(String) }
-    attr_reader :name, :type
+    attr_reader :name
+
+    sig { returns(T.any(Type, String)) }
+    attr_reader :type
 
     sig do
       params(
         name: String,
-        type: String,
+        type: T.any(Type, String),
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
         block: T.nilable(T.proc.params(node: SigParam).void),
@@ -1199,7 +1206,7 @@ module RBI
 
     sig { params(other: Object).returns(T::Boolean) }
     def ==(other)
-      other.is_a?(SigParam) && name == other.name && type == other.type
+      other.is_a?(SigParam) && name == other.name && type.to_s == other.type.to_s
     end
   end
 
@@ -1229,7 +1236,10 @@ module RBI
     abstract!
 
     sig { returns(String) }
-    attr_accessor :name, :type
+    attr_accessor :name
+
+    sig { returns(T.any(Type, String)) }
+    attr_accessor :type
 
     sig { returns(T.nilable(String)) }
     attr_accessor :default
@@ -1237,7 +1247,7 @@ module RBI
     sig do
       params(
         name: String,
-        type: String,
+        type: T.any(Type, String),
         default: T.nilable(String),
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
@@ -1260,7 +1270,7 @@ module RBI
     sig do
       params(
         name: String,
-        type: String,
+        type: T.any(Type, String),
         default: T.nilable(String),
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
@@ -1290,7 +1300,7 @@ module RBI
     sig do
       params(
         name: String,
-        type: String,
+        type: T.any(Type, String),
         default: T.nilable(String),
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
@@ -1333,39 +1343,29 @@ module RBI
     end
   end
 
-  class TEnumBlock < NodeWithComments
+  class TEnumBlock < Scope
     extend T::Sig
 
-    sig { returns(T::Array[String]) }
-    attr_reader :names
-
     sig do
       params(
-        names: T::Array[String],
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
         block: T.nilable(T.proc.params(node: TEnumBlock).void),
       ).void
     end
-    def initialize(names = [], loc: nil, comments: [], &block)
-      super(loc: loc, comments: comments)
-      @names = names
+    def initialize(loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments) {}
       block&.call(self)
     end
 
-    sig { returns(T::Boolean) }
-    def empty?
-      names.empty?
-    end
-
-    sig { params(name: String).void }
-    def <<(name)
-      @names << name
+    sig { override.returns(String) }
+    def fully_qualified_name
+      "#{parent_scope&.fully_qualified_name}.enums"
     end
 
     sig { override.returns(String) }
     def to_s
-      "#{parent_scope&.fully_qualified_name}.enums"
+      fully_qualified_name
     end
   end
 

data/lib/rbi/parser.rb

@@ -169,22 +169,38 @@ module RBI
         @scopes_stack = T.let([@tree], T::Array[Tree])
         @last_node = T.let(nil, T.nilable(Prism::Node))
         @last_sigs = T.let([], T::Array[RBI::Sig])
-        @last_sigs_comments = T.let([], T::Array[Comment])
       end
 
       sig { override.params(node: Prism::ClassNode).void }
       def visit_class_node(node)
         @last_node = node
-        scope = Class.new(
-          node_string!(node.constant_path),
-          superclass_name: node_string(node.superclass),
-          loc: node_loc(node),
-          comments: node_comments(node),
-        )
+        superclass_name = node_string(node.superclass)
+        scope = case superclass_name
+        when /^(::)?T::Struct$/
+          TStruct.new(
+            node_string!(node.constant_path),
+            loc: node_loc(node),
+            comments: node_comments(node),
+          )
+        when /^(::)?T::Enum$/
+          TEnum.new(
+            node_string!(node.constant_path),
+            loc: node_loc(node),
+            comments: node_comments(node),
+          )
+        else
+          Class.new(
+            node_string!(node.constant_path),
+            superclass_name: superclass_name,
+            loc: node_loc(node),
+            comments: node_comments(node),
+          )
+        end
 
         current_scope << scope
         @scopes_stack << scope
         visit(node.body)
+        scope.nodes.concat(current_sigs)
         collect_dangling_comments(node)
         @scopes_stack.pop
         @last_node = nil
@@ -240,12 +256,19 @@ module RBI
       sig { override.params(node: Prism::DefNode).void }
       def visit_def_node(node)
         @last_node = node
+
+        # We need to collect the comments with `current_sigs_comments` _before_ visiting the parameters to make sure
+        # the method comments are properly associated with the sigs and not the parameters.
+        sigs = current_sigs
+        comments = detach_comments_from_sigs(sigs) + node_comments(node)
+        params = parse_params(node.parameters)
+
         current_scope << Method.new(
           node.name.to_s,
-          params: parse_params(node.parameters),
-          sigs: current_sigs,
+          params: params,
+          sigs: sigs,
           loc: node_loc(node),
-          comments: current_sigs_comments + node_comments(node),
+          comments: comments,
           is_singleton: !!node.receiver,
         )
         @last_node = nil
@@ -263,6 +286,7 @@ module RBI
         current_scope << scope
         @scopes_stack << scope
         visit(node.body)
+        scope.nodes.concat(current_sigs)
         collect_dangling_comments(node)
         @scopes_stack.pop
         @last_node = nil
@@ -272,7 +296,7 @@ module RBI
       def visit_program_node(node)
         @last_node = node
         super
-
+        @tree.nodes.concat(current_sigs)
         collect_orphan_comments
         separate_header_comments
         set_root_tree_loc
@@ -290,6 +314,7 @@ module RBI
         current_scope << scope
         @scopes_stack << scope
         visit(node.body)
+        scope.nodes.concat(current_sigs)
         collect_dangling_comments(node)
         @scopes_stack.pop
         @last_node = nil
@@ -314,11 +339,14 @@ module RBI
             return
           end
 
+          sigs = current_sigs
+          comments = detach_comments_from_sigs(sigs) + node_comments(node)
+
           current_scope << AttrReader.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
-            sigs: current_sigs,
+            sigs: sigs,
             loc: node_loc(node),
-            comments: current_sigs_comments + node_comments(node),
+            comments: comments,
           )
         when "attr_writer"
           args = node.arguments
@@ -328,11 +356,14 @@ module RBI
             return
           end
 
+          sigs = current_sigs
+          comments = detach_comments_from_sigs(sigs) + node_comments(node)
+
           current_scope << AttrWriter.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
-            sigs: current_sigs,
+            sigs: sigs,
             loc: node_loc(node),
-            comments: current_sigs_comments + node_comments(node),
+            comments: comments,
           )
         when "attr_accessor"
           args = node.arguments
@@ -342,32 +373,30 @@ module RBI
             return
           end
 
+          sigs = current_sigs
+          comments = detach_comments_from_sigs(sigs) + node_comments(node)
+
           current_scope << AttrAccessor.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
-            sigs: current_sigs,
+            sigs: sigs,
             loc: node_loc(node),
-            comments: current_sigs_comments + node_comments(node),
+            comments: comments,
           )
         when "enums"
-          block = node.block
-
-          unless block.is_a?(Prism::BlockNode)
-            @last_node = nil
-            return
-          end
-
-          body = block.body
-
-          unless body.is_a?(Prism::StatementsNode)
-            @last_node = nil
-            return
+          if node.block && node.arguments.nil?
+            scope = TEnumBlock.new(loc: node_loc(node), comments: node_comments(node))
+            current_scope << scope
+            @scopes_stack << scope
+            visit(node.block)
+            @scopes_stack.pop
+          else
+            current_scope << Send.new(
+              message,
+              parse_send_args(node.arguments),
+              loc: node_loc(node),
+              comments: node_comments(node),
+            )
           end
-
-          current_scope << TEnumBlock.new(
-            body.body.map { |stmt| T.cast(stmt, Prism::ConstantWriteNode).name.to_s },
-            loc: node_loc(node),
-            comments: node_comments(node),
-          )
         when "extend"
           args = node.arguments
 
@@ -415,6 +444,13 @@ module RBI
             case last_node
             when Method, Attr
               last_node.visibility = parse_visibility(node.name.to_s, node)
+            when Send
+              current_scope << Send.new(
+                message,
+                parse_send_args(node.arguments),
+                loc: node_loc(node),
+                comments: node_comments(node),
+              )
             else
               raise ParseError.new(
                 "Unexpected token `#{node.message}` before `#{last_node&.string&.strip}`",
@@ -470,7 +506,7 @@ module RBI
 
         last_node_last_line = node.child_nodes.last&.location&.end_line
 
-        last_line.downto(first_line) do |line|
+        first_line.upto(last_line) do |line|
           comment = @comments_by_line[line]
           next unless comment
           break if last_node_last_line && line <= last_node_last_line
@@ -516,10 +552,15 @@ module RBI
         sigs
       end
 
-      sig { returns(T::Array[Comment]) }
-      def current_sigs_comments
-        comments = @last_sigs_comments.dup
-        @last_sigs_comments.clear
+      sig { params(sigs: T::Array[Sig]).returns(T::Array[Comment]) }
+      def detach_comments_from_sigs(sigs)
+        comments = T.let([], T::Array[Comment])
+
+        sigs.each do |sig|
+          comments += sig.comments.dup
+          sig.comments.clear
+        end
+
         comments
       end
 
@@ -646,11 +687,10 @@ module RBI
 
       sig { params(node: Prism::CallNode).returns(Sig) }
       def parse_sig(node)
-        @last_sigs_comments = node_comments(node)
-
         builder = SigBuilder.new(@source, file: @file)
         builder.current.loc = node_loc(node)
         builder.visit_call_node(node)
+        builder.current.comments = node_comments(node)
         builder.current
       end
 
@@ -745,11 +785,11 @@ module RBI
       def parse_visibility(name, node)
         case name
         when "public"
-          Public.new(loc: node_loc(node))
+          Public.new(loc: node_loc(node), comments: node_comments(node))
         when "protected"
-          Protected.new(loc: node_loc(node))
+          Protected.new(loc: node_loc(node), comments: node_comments(node))
         when "private"
-          Private.new(loc: node_loc(node))
+          Private.new(loc: node_loc(node), comments: node_comments(node))
         else
           raise ParseError.new("Unexpected visibility `#{name}`", node_loc(node))
         end
@@ -781,10 +821,7 @@ module RBI
 
       sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
       def type_variable_definition?(node)
-        return false unless node.is_a?(Prism::CallNode)
-        return false unless node.block
-
-        node.message == "type_member" || node.message == "type_template"
+        node.is_a?(Prism::CallNode) && (node.message == "type_member" || node.message == "type_template")
       end
     end
 
@@ -839,7 +876,7 @@ module RBI
             end
           end
         when "void"
-          @current.return_type = nil
+          @current.return_type = "void"
         end
 
         visit(node.receiver)

data/lib/rbi/printer.rb

@@ -169,6 +169,10 @@ module RBI
       case node
       when Module
         printt("module #{node.name}")
+      when TEnum
+        printt("class #{node.name} < T::Enum")
+      when TStruct
+        printt("class #{node.name} < T::Struct")
       when Class
         printt("class #{node.name}")
         superclass = node.superclass_name
@@ -184,10 +188,6 @@ module RBI
         end
       when SingletonClass
         printt("class << self")
-      when TStruct
-        printt("class #{node.name} < T::Struct")
-      when TEnum
-        printt("class #{node.name} < T::Enum")
       else
         raise PrinterError, "Unhandled node: #{node.class}"
       end
@@ -426,6 +426,7 @@ module RBI
     sig { override.params(node: Sig).void }
     def visit_sig(node)
       print_loc(node)
+      visit_all(node.comments)
 
       max_line_length = self.max_line_length
       if oneline?(node) && max_line_length.nil?
@@ -492,9 +493,7 @@ module RBI
 
       printl("enums do")
       indent
-      node.names.each do |name|
-        printl("#{name} = new")
-      end
+      visit_all(node.nodes)
       dedent
       printl("end")
     end
@@ -611,7 +610,7 @@ module RBI
     def print_sig_param_comment_leading_space(node, last:)
       printn
       printt
-      print(" " * (node.name.size + node.type.size + 3))
+      print(" " * (node.name.size + node.type.to_s.size + 3))
       print(" ") unless last
     end
 
@@ -654,10 +653,10 @@ module RBI
         print(").")
       end
       return_type = node.return_type
-      if node.return_type && node.return_type != "void"
-        print("returns(#{return_type})")
-      else
+      if node.return_type.to_s == "void"
         print("void")
+      else
+        print("returns(#{return_type})")
       end
       printn(" }")
     end
@@ -707,10 +706,10 @@ module RBI
       print(".") if modifiers.any? || params.any?
 
       return_type = node.return_type
-      if return_type && return_type != "void"
-        print("returns(#{return_type})")
-      else
+      if return_type.to_s == "void"
         print("void")
+      else
+        print("returns(#{return_type})")
       end
       printn
       dedent

data/lib/rbi/rewriters/attr_to_methods.rb

@@ -62,7 +62,7 @@ module RBI
 
     private
 
-    sig(:final) { returns([T.nilable(Sig), T.nilable(String)]) }
+    sig(:final) { returns([T.nilable(Sig), T.nilable(T.any(Type, String))]) }
     def parse_sig
       raise UnexpectedMultipleSigsError, self if 1 < sigs.count
 
@@ -101,7 +101,7 @@ module RBI
       params(
         name: String,
         sig: T.nilable(Sig),
-        attribute_type: T.nilable(String),
+        attribute_type: T.nilable(T.any(Type, String)),
         visibility: Visibility,
         loc: T.nilable(Loc),
         comments: T::Array[Comment],

data/lib/rbi/rewriters/flatten_singleton_methods.rb

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    # Rewrite non-singleton methods inside singleton classes to singleton methods
+    #
+    # Example:
+    # ~~~rb
+    # class << self
+    #  def m1; end
+    #  def self.m2; end
+    #
+    #  class << self
+    #    def m3; end
+    #  end
+    # end
+    # ~~~
+    #
+    # will be rewritten to:
+    #
+    # ~~~rb
+    # def self.m1; end
+    #
+    # class << self
+    #   def self.m2; end
+    #   def self.m3; end
+    # end
+    # ~~~
+    class FlattenSingletonMethods < Visitor
+      extend T::Sig
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when SingletonClass
+          node.nodes.dup.each do |child|
+            visit(child)
+            next unless child.is_a?(Method) && !child.is_singleton
+
+            child.detach
+            child.is_singleton = true
+            T.must(node.parent_tree) << child
+          end
+
+          node.detach if node.nodes.empty?
+        when Tree
+          visit_all(node.nodes)
+        end
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { void }
+    def flatten_singleton_methods!
+      visitor = Rewriters::FlattenSingletonMethods.new
+      visitor.visit(self)
+    end
+  end
+end