rbs 4.1.0.pre.2-java

data/lib/rbs/wasm/serialization_schema.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+#
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. To change the template see
+#   templates/lib/rbs/wasm/serialization_schema.rb.erb
+
+module RBS
+  module WASM
+    # Describes how to decode the binary buffer produced by `rbs_serialize_node`
+    # (src/serialize.c) back into RBS::AST objects. RBS::WASM::Deserializer walks
+    # this table; the matching encoder is generated from the same config.yml, so
+    # the two stay in sync.
+    #
+    # SCHEMA is indexed by node tag: tag 0 is NULL and SYMBOL_TAG is the
+    # interned-symbol tag. Each remaining entry is one of:
+    #
+    #   [:node, class_name, expose_location, loc_children, fields, resolve_type_params]
+    #   [:bool] / [:integer] / [:string_value] / [:record_field]
+    #   [:signature] / [:namespace] / [:type_name]
+    #
+    # where loc_children is [[name, required?], ...] and fields is
+    # [[name, reader], ...] with reader one of :node, :node_list, :hash, :string,
+    # :bool, :location_range, :location_range_list, :attr_ivar_name, or
+    # [:enum, [value_or_nil, ...]].
+    module SerializationSchema
+      SYMBOL_TAG = 78
+
+      SCHEMA = [
+        nil, # tag 0 is reserved for NULL
+        [:node, "RBS::AST::Annotation", true, nil, [[:string, :string]], false],
+        [:bool],
+        [:node, "RBS::AST::Comment", true, nil, [[:string, :string]], false],
+        [:node, "RBS::AST::Declarations::Class", true, [[:keyword, true], [:name, true], [:end, true], [:type_params, false], [:lt, false]], [[:name, :node], [:type_params, :node_list], [:super_class, :node], [:members, :node_list], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Declarations::Class::Super", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::AST::Declarations::ClassAlias", true, [[:keyword, true], [:new_name, true], [:eq, true], [:old_name, true]], [[:new_name, :node], [:old_name, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::Constant", true, [[:name, true], [:colon, true]], [[:name, :node], [:type, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::Global", true, [[:name, true], [:colon, true]], [[:name, :node], [:type, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::Interface", true, [[:keyword, true], [:name, true], [:end, true], [:type_params, false]], [[:name, :node], [:type_params, :node_list], [:members, :node_list], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Declarations::Module", true, [[:keyword, true], [:name, true], [:end, true], [:type_params, false], [:colon, false], [:self_types, false]], [[:name, :node], [:type_params, :node_list], [:self_types, :node_list], [:members, :node_list], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Declarations::Module::Self", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::AST::Declarations::ModuleAlias", true, [[:keyword, true], [:new_name, true], [:eq, true], [:old_name, true]], [[:new_name, :node], [:old_name, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::TypeAlias", true, [[:keyword, true], [:name, true], [:eq, true], [:type_params, false]], [[:name, :node], [:type_params, :node_list], [:type, :node], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Directives::Use", true, [[:keyword, true]], [[:clauses, :node_list]], false],
+        [:node, "RBS::AST::Directives::Use::SingleClause", true, [[:type_name, true], [:keyword, false], [:new_name, false]], [[:type_name, :node], [:new_name, :node]], false],
+        [:node, "RBS::AST::Directives::Use::WildcardClause", true, [[:namespace, true], [:star, true]], [[:namespace, :node]], false],
+        [:integer],
+        [:node, "RBS::AST::Members::Alias", true, [[:keyword, true], [:new_name, true], [:old_name, true], [:new_kind, false], [:old_kind, false]], [[:new_name, :node], [:old_name, :node], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::AttrAccessor", true, [[:keyword, true], [:name, true], [:colon, true], [:kind, false], [:ivar, false], [:ivar_name, false], [:visibility, false]], [[:name, :node], [:type, :node], [:ivar_name, :attr_ivar_name], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::AttrReader", true, [[:keyword, true], [:name, true], [:colon, true], [:kind, false], [:ivar, false], [:ivar_name, false], [:visibility, false]], [[:name, :node], [:type, :node], [:ivar_name, :attr_ivar_name], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::AttrWriter", true, [[:keyword, true], [:name, true], [:colon, true], [:kind, false], [:ivar, false], [:ivar_name, false], [:visibility, false]], [[:name, :node], [:type, :node], [:ivar_name, :attr_ivar_name], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::ClassInstanceVariable", true, [[:name, true], [:colon, true], [:kind, false]], [[:name, :node], [:type, :node], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::ClassVariable", true, [[:name, true], [:colon, true], [:kind, false]], [[:name, :node], [:type, :node], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::Extend", true, [[:name, true], [:keyword, true], [:args, false]], [[:name, :node], [:args, :node_list], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::Include", true, [[:name, true], [:keyword, true], [:args, false]], [[:name, :node], [:args, :node_list], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::InstanceVariable", true, [[:name, true], [:colon, true], [:kind, false]], [[:name, :node], [:type, :node], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::MethodDefinition", true, [[:keyword, true], [:name, true], [:kind, false], [:overloading, false], [:visibility, false]], [[:name, :node], [:kind, [:enum, [:instance, :singleton, :singleton_instance]]], [:overloads, :node_list], [:annotations, :node_list], [:comment, :node], [:overloading, :bool], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::MethodDefinition::Overload", false, nil, [[:annotations, :node_list], [:method_type, :node]], false],
+        [:node, "RBS::AST::Members::Prepend", true, [[:name, true], [:keyword, true], [:args, false]], [[:name, :node], [:args, :node_list], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::Private", true, nil, nil, false],
+        [:node, "RBS::AST::Members::Public", true, nil, nil, false],
+        [:node, "RBS::AST::Ruby::Annotations::BlockParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:ampersand_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:question_location, :location_range], [:type_location, :location_range], [:type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ClassAliasAnnotation", true, nil, [[:prefix_location, :location_range], [:keyword_location, :location_range], [:type_name, :node], [:type_name_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ColonMethodTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:annotations, :node_list], [:method_type, :node]], false],
+        [:node, "RBS::AST::Ruby::Annotations::DoubleSplatParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:star2_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:param_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::InstanceVariableAnnotation", true, nil, [[:prefix_location, :location_range], [:ivar_name, :node], [:ivar_name_location, :location_range], [:colon_location, :location_range], [:type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::MethodTypesAnnotation", true, nil, [[:prefix_location, :location_range], [:overloads, :node_list], [:vertical_bar_locations, :location_range_list], [:dot3_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ModuleAliasAnnotation", true, nil, [[:prefix_location, :location_range], [:keyword_location, :location_range], [:type_name, :node], [:type_name_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ModuleSelfAnnotation", true, nil, [[:prefix_location, :location_range], [:keyword_location, :location_range], [:colon_location, :location_range], [:name, :node], [:args, :node_list], [:open_bracket_location, :location_range], [:close_bracket_location, :location_range], [:args_comma_locations, :location_range_list], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::NodeTypeAssertion", true, nil, [[:prefix_location, :location_range], [:type, :node]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:param_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ReturnTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:return_location, :location_range], [:colon_location, :location_range], [:return_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::SkipAnnotation", true, nil, [[:prefix_location, :location_range], [:skip_location, :location_range], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::SplatParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:star_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:param_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::TypeApplicationAnnotation", true, nil, [[:prefix_location, :location_range], [:type_args, :node_list], [:close_bracket_location, :location_range], [:comma_locations, :location_range_list]], false],
+        [:string_value],
+        [:node, "RBS::AST::TypeParam", true, [[:name, true], [:variance, false], [:unchecked, false], [:upper_bound, false], [:lower_bound, false], [:default, false]], [[:name, :node], [:variance, [:enum, [:invariant, :covariant, :contravariant]]], [:upper_bound, :node], [:lower_bound, :node], [:default_type, :node], [:unchecked, :bool]], false],
+        [:node, "RBS::MethodType", true, [[:type, true], [:type_params, false]], [[:type_params, :node_list], [:type, :node], [:block, :node]], true],
+        [:namespace],
+        [:signature],
+        [:type_name],
+        [:node, "RBS::Types::Alias", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::Types::Bases::Any", true, nil, [[:todo, :bool]], false],
+        [:node, "RBS::Types::Bases::Bool", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Bottom", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Class", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Instance", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Nil", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Self", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Top", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Void", true, nil, nil, false],
+        [:node, "RBS::Types::Block", true, nil, [[:type, :node], [:required, :bool], [:self_type, :node]], false],
+        [:node, "RBS::Types::ClassInstance", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::Types::ClassSingleton", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::Types::Function", false, nil, [[:required_positionals, :node_list], [:optional_positionals, :node_list], [:rest_positionals, :node], [:trailing_positionals, :node_list], [:required_keywords, :hash], [:optional_keywords, :hash], [:rest_keywords, :node], [:return_type, :node]], false],
+        [:node, "RBS::Types::Function::Param", true, [[:name, false]], [[:type, :node], [:name, :node]], false],
+        [:node, "RBS::Types::Interface", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::Types::Intersection", true, nil, [[:types, :node_list]], false],
+        [:node, "RBS::Types::Literal", true, nil, [[:literal, :node]], false],
+        [:node, "RBS::Types::Optional", true, nil, [[:type, :node]], false],
+        [:node, "RBS::Types::Proc", true, nil, [[:type, :node], [:block, :node], [:self_type, :node]], false],
+        [:node, "RBS::Types::Record", true, nil, [[:all_fields, :hash]], false],
+        [:record_field],
+        [:node, "RBS::Types::Tuple", true, nil, [[:types, :node_list]], false],
+        [:node, "RBS::Types::Union", true, nil, [[:types, :node_list]], false],
+        [:node, "RBS::Types::UntypedFunction", false, nil, [[:return_type, :node]], false],
+        [:node, "RBS::Types::Variable", true, nil, [[:name, :node]], false],
+      ].freeze
+    end
+  end
+end

data/lib/rbs/writer.rb

@@ -0,0 +1,424 @@
+# frozen_string_literal: true
+
+module RBS
+  class Writer
+    attr_reader :out
+    attr_reader :indentation
+
+    def initialize(out:)
+      @out = out
+      @indentation = []
+      @preserve = false
+    end
+
+    def preserve?
+      @preserve
+    end
+
+    def preserve!(preserve: true)
+      @preserve = preserve
+      self
+    end
+
+    def indent(size = 2)
+      indentation.push(" " * size)
+      yield
+    ensure
+      indentation.pop
+    end
+
+    def prefix
+      indentation.join()
+    end
+
+    def puts(string = "")
+      if string.size > 0
+        @out.puts("#{prefix}#{string}")
+      else
+        @out.puts
+      end
+    end
+
+    def format_annotation(annotation)
+      string = annotation.string
+      case
+      when string !~ /\}/
+        "%a{#{string}}"
+      when string !~ /\)/
+        "%a(#{string})"
+      when string !~ /\]/
+        "%a[#{string}]"
+      when string !~ /\>/
+        "%a<#{string}>"
+      when string !~ /\|/
+        "%a|#{string}|"
+      else
+        raise
+      end
+    end
+
+    def write_annotation(annotations)
+      annotations.each do |annotation|
+        puts format_annotation(annotation)
+      end
+    end
+
+    def write_comment(comment)
+      if comment
+        comment.string.lines.each do |line|
+          line = line.chomp
+          unless line.empty?
+            puts "# #{line}"
+          else
+            puts "#"
+          end
+        end
+      end
+    end
+
+    def write(contents)
+      resolves = contents.select { _1.is_a?(AST::Directives::ResolveTypeNames) } #: Array[AST::Directives::ResolveTypeNames]
+      uses = contents.select {|c| c.is_a?(AST::Directives::Use) } #: Array[AST::Directives::Use]
+      decls = contents.select {|c| c.is_a?(AST::Declarations::Base) } #: Array[AST::Declarations::t]
+
+      if first_resolves = resolves.first
+        puts "# resolve-type-names: #{first_resolves.value}"
+        puts
+      end
+
+      uses.each do |dir|
+        write_use_directive(dir)
+      end
+      puts unless uses.empty?
+
+      [nil, *decls].each_cons(2) do |prev, decl|
+        raise unless decl
+
+        preserve_empty_line(prev, decl)
+        write_decl decl
+      end
+    end
+
+    def write_use_directive(dir)
+      clauses = dir.clauses.map do |clause|
+        case clause
+        when AST::Directives::Use::SingleClause
+          if clause.new_name
+            "#{clause.type_name} as #{clause.new_name}"
+          else
+            "#{clause.type_name}"
+          end
+        when AST::Directives::Use::WildcardClause
+          "#{clause.namespace}*"
+        end
+      end
+
+      puts "use #{clauses.join(", ")}"
+    end
+
+    def write_decl(decl)
+      case decl
+      when AST::Declarations::Class
+        super_class = if super_class = decl.super_class
+                        " < #{name_and_args(super_class.name, super_class.args)}"
+                      end
+        write_comment decl.comment
+        write_annotation decl.annotations
+        puts "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+
+        indent do
+          [nil, *decl.members].each_cons(2) do |prev, member|
+            raise unless member
+
+            preserve_empty_line prev, member
+            write_member member
+          end
+        end
+
+        puts "end"
+
+      when AST::Declarations::Module
+        self_type = unless decl.self_types.empty?
+                      " : #{decl.self_types.join(", ")}"
+                    end
+
+        write_comment decl.comment
+        write_annotation decl.annotations
+
+        puts "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+
+        indent do
+          decl.members.each.with_index do |member, index|
+            if index > 0
+              puts
+            end
+            write_member member
+          end
+        end
+
+        puts "end"
+      when AST::Declarations::Constant
+        write_comment decl.comment
+        puts "#{decl.name}: #{decl.type}"
+
+      when AST::Declarations::Global
+        write_comment decl.comment
+        puts "#{decl.name}: #{decl.type}"
+
+      when AST::Declarations::TypeAlias
+        write_comment decl.comment
+        write_annotation decl.annotations
+        write_loc_source(decl) {
+          puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
+        }
+
+      when AST::Declarations::ClassAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "class #{decl.new_name} = #{decl.old_name}"
+        }
+
+      when AST::Declarations::ModuleAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "module #{decl.new_name} = #{decl.old_name}"
+        }
+
+      when AST::Declarations::Interface
+        write_comment decl.comment
+        write_annotation decl.annotations
+
+        puts "interface #{name_and_params(decl.name, decl.type_params)}"
+
+        indent do
+          decl.members.each.with_index do |member, index|
+            if index > 0
+              puts
+            end
+            write_member member
+          end
+        end
+
+        puts "end"
+
+      end
+    end
+
+    def name_and_params(name, params)
+      if params.empty?
+        "#{name}"
+      else
+        ps = params.each.map do |param|
+          param.to_s
+        end
+
+        "#{name}[#{ps.join(", ")}]"
+      end
+    end
+
+    def name_and_args(name, args)
+      if name && args
+        if args.empty?
+          "#{name}"
+        else
+          "#{name}[#{args.join(", ")}]"
+        end
+      end
+    end
+
+    def put_lines(lines, leading_spaces:)
+      lines.each_line.with_index do |line, index|
+        line.chomp!
+        line.rstrip!
+        line.sub!(/\A( {,#{leading_spaces}})/, '') if index > 0
+
+        puts line
+      end
+    end
+
+    def write_member(member)
+      case member
+      when AST::Members::Include
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "include #{name_and_args(member.name, member.args)}"
+      when AST::Members::Extend
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "extend #{name_and_args(member.name, member.args)}"
+      when AST::Members::Prepend
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "prepend #{name_and_args(member.name, member.args)}"
+      when AST::Members::AttrAccessor
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:accessor, member)}"
+      when AST::Members::AttrReader
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:reader, member)}"
+      when AST::Members::AttrWriter
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:writer, member)}"
+      when AST::Members::Public
+        puts "public"
+      when AST::Members::Private
+        puts "private"
+      when AST::Members::Alias
+        write_comment member.comment
+        write_annotation member.annotations
+        new_name = member.singleton? ? "self.#{method_name(member.new_name)}" : method_name(member.new_name)
+        old_name = member.singleton? ? "self.#{method_name(member.old_name)}" : method_name(member.old_name)
+        puts "alias #{new_name} #{old_name}"
+      when AST::Members::InstanceVariable
+        write_comment member.comment
+        puts "#{member.name}: #{member.type}"
+      when AST::Members::ClassInstanceVariable
+        write_comment member.comment
+        puts "self.#{member.name}: #{member.type}"
+      when AST::Members::ClassVariable
+        write_comment member.comment
+        puts "#{member.name}: #{member.type}"
+      when AST::Members::MethodDefinition
+        write_comment member.comment
+        write_annotation member.annotations
+        write_loc_source(member) { write_def member }
+      else
+        write_decl member
+      end
+    end
+
+    def method_name(name)
+      s = name.to_s
+
+      case s
+      when /\A(_?)[A-Za-z_]\w*(\?|!|=)?\Z/
+        s
+      when *%w(|  ^  &  <=>  ==  ===  =~  >   >=  <   <=   <<  >> +  -  *  /  %   **   ~   +@  -@  []  []=  ` ! != !~)
+        s
+      else
+        "`#{s}`"
+      end
+    end
+
+    def write_loc_source(located)
+      if preserve? && loc = located.location
+        put_lines(loc.source, leading_spaces: loc.start_column)
+      else
+        yield
+      end
+    end
+
+    def write_def(member)
+      visibility =
+        case member.visibility
+        when :public
+          "public "
+        when :private
+          "private "
+        else
+          ""
+        end
+
+      name = case member.kind
+             when :instance
+               "#{method_name(member.name)}"
+             when :singleton_instance
+               "self?.#{method_name(member.name)}"
+             when :singleton
+               "self.#{method_name(member.name)}"
+             end
+
+      string = +""
+
+      prefix = "#{visibility}def #{name}:"
+      padding = " " * (prefix.size-1)
+
+      string << prefix
+
+      member.overloads.each.with_index do |overload, index|
+        if index > 0
+          string << padding
+          string << "|"
+        end
+
+        overload.annotations.each do |annotation|
+          string << " #{format_annotation(annotation)}"
+        end
+        string << " #{overload.method_type}\n"
+      end
+
+      if member.overloading?
+        if member.overloads.size > 0
+          string << padding
+          string << "|"
+        end
+        string << " ...\n"
+      end
+
+      string.each_line do |line|
+        puts line.chomp
+      end
+    end
+
+    def attribute(kind, attr)
+      visibility =
+        case attr.visibility
+        when :public
+          "public "
+        when :private
+          "private "
+        else
+          ""
+        end
+
+      var = case attr.ivar_name
+            when nil
+              ""
+            when false
+              "()"
+            else
+              "(#{attr.ivar_name})"
+            end
+
+      receiver = case attr.kind
+                 when :singleton
+                   "self."
+                 when :instance
+                   ""
+                 end
+
+      "#{visibility}attr_#{kind} #{receiver}#{method_name(attr.name)}#{var}: #{attr.type}"
+    end
+
+    def preserve_empty_line(prev, decl)
+      # @type var decl: _Located
+
+      return unless prev
+
+      if (_ = decl).respond_to?(:comment)
+        if comment = (_ = decl).comment
+          decl = comment
+        end
+      end
+
+      prev_loc = prev.location
+      decl_loc = decl.location
+
+      if prev_loc && decl_loc
+        prev_end_line = prev_loc.end_line
+        start_line = decl_loc.start_line
+
+        if start_line - prev_end_line > 1
+          puts
+        end
+      else
+        # When the signature is not constructed by the parser,
+        # it always inserts an empty line.
+        puts
+      end
+    end
+  end
+end

data/lib/rbs.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "rbs/version"
+
+require "set"
+require "json"
+# Always require pathname: `Pathname()` (Kernel#Pathname) is only defined once
+# pathname is loaded. Guarding on `defined?(Pathname)` is wrong because another
+# library (e.g. Bundler) can define the Pathname constant without that method,
+# which left RBS::EnvironmentLoader's `Pathname(...)` undefined on JRuby.
+require "pathname"
+require "pp"
+require "logger"
+require "tsort"
+require "strscan"
+require "prism"
+
+require "rbs/errors"
+require "rbs/buffer"
+require "rbs/namespace"
+require "rbs/type_name"
+require "rbs/types"
+require "rbs/method_type"
+require "rbs/file_finder"
+require "rbs/ast/type_param"
+require "rbs/ast/directives"
+require "rbs/ast/declarations"
+require "rbs/ast/members"
+require "rbs/ast/annotation"
+require "rbs/ast/visitor"
+require "rbs/ast/ruby/comment_block"
+require "rbs/ast/ruby/helpers/constant_helper"
+require "rbs/ast/ruby/helpers/location_helper"
+require "rbs/ast/ruby/annotations"
+require "rbs/ast/ruby/declarations"
+require "rbs/ast/ruby/members"
+require "rbs/source"
+require "rbs/inline_parser"
+require "rbs/inline_parser/comment_association"
+require "rbs/environment"
+require "rbs/environment/use_map"
+require "rbs/environment/class_entry"
+require "rbs/environment/module_entry"
+require "rbs/environment_loader"
+require "rbs/builtin_names"
+require "rbs/definition"
+require "rbs/definition_builder"
+require "rbs/definition_builder/ancestor_builder"
+require "rbs/definition_builder/method_builder"
+require "rbs/diff"
+require "rbs/variance_calculator"
+require "rbs/substitution"
+require "rbs/constant"
+require "rbs/resolver/constant_resolver"
+require "rbs/resolver/type_name_resolver"
+require "rbs/ast/comment"
+require "rbs/writer"
+require "rbs/rewriter"
+require "rbs/prototype/helpers"
+require "rbs/prototype/rbi"
+require "rbs/prototype/rb"
+require "rbs/prototype/runtime"
+require "rbs/prototype/node_usage"
+require "rbs/environment_walker"
+require "rbs/vendorer"
+require "rbs/validator"
+require "rbs/factory"
+require "rbs/repository"
+require "rbs/subtractor"
+require "rbs/ancestor_graph"
+require "rbs/locator"
+require "rbs/type_alias_dependency"
+require "rbs/type_alias_regularity"
+require "rbs/collection"
+
+if RUBY_ENGINE == "jruby"
+  # JRuby cannot load the MRI C extension. Run the parser in WebAssembly and
+  # provide pure-Ruby implementations of RBS::Location and RBS::Parser instead.
+  require "rbs/wasm/location"
+  require "rbs/wasm/parser"
+else
+  require "rbs_extension"
+end
+require "rbs/parser_aux"
+require "rbs/location_aux"
+
+module RBS
+  class <<self
+    attr_reader :logger_level
+    attr_reader :logger_output
+
+    def logger
+      @logger ||= Logger.new(logger_output || STDERR, level: logger_level || Logger::WARN, progname: "rbs")
+    end
+
+    def logger_output=(val)
+      @logger = nil
+      @logger_output = val
+    end
+
+    def logger_level=(level)
+      @logger_level = level
+      @logger = nil
+    end
+
+    def print_warning()
+      @warnings ||= Set[]
+
+      message = yield()
+
+      unless @warnings.include?(message)
+        @warnings << message
+        logger.warn { message }
+      end
+    end
+  end
+end

data/lib/rdoc/discover.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+begin
+  gem 'rdoc', '>= 6.16'
+  require 'rdoc_plugin/parser'
+  module RDoc
+    class Parser
+      class RBS < Parser
+        parse_files_matching(/\.rbs$/)
+        def scan
+          ::RBS::RDocPlugin::Parser.new(@top_level, @content).scan
+        end
+      end
+    end
+  end
+rescue Gem::LoadError
+    # Error :sad:
+rescue Exception
+    # Exception :sad:
+end