rbs 2.0.0 → 2.2.2

data/lib/rbs/writer.rb

@@ -6,6 +6,16 @@ module RBS
     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)
@@ -119,7 +129,9 @@ module RBS
       when AST::Declarations::Alias
         write_comment decl.comment
         write_annotation decl.annotations
-        puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
+        write_loc_source(decl) {
+          puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
+        }
 
       when AST::Declarations::Interface
         write_comment decl.comment
@@ -163,6 +175,16 @@ module RBS
       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
@@ -211,7 +233,7 @@ module RBS
       when AST::Members::MethodDefinition
         write_comment member.comment
         write_annotation member.annotations
-        write_def member
+        write_loc_source(member) { write_def member }
       else
         write_decl member
       end
@@ -230,7 +252,25 @@ module RBS
       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)}"
@@ -242,7 +282,7 @@ module RBS
 
       string = ""
 
-      prefix = "def #{name}:"
+      prefix = "#{visibility}def #{name}:"
       padding = " " * (prefix.size-1)
 
       string << prefix
@@ -270,6 +310,16 @@ module RBS
     end
 
     def attribute(kind, attr)
+      visibility =
+        case attr.visibility
+        when :public
+          "public "
+        when :private
+          "private "
+        else
+          ""
+        end
+
       var = case attr.ivar_name
             when nil
               ""
@@ -286,7 +336,7 @@ module RBS
                    ""
                  end
 
-      "attr_#{kind} #{receiver}#{attr.name}#{var}: #{attr.type}"
+      "#{visibility}attr_#{kind} #{receiver}#{attr.name}#{var}: #{attr.type}"
     end
 
     def preserve_empty_line(prev, decl)

data/lib/rbs.rb

@@ -7,9 +7,7 @@ require "pp"
 require "ripper"
 require "logger"
 require "tsort"
-require "strscan"
 
-require "rbs/char_scanner"
 require "rbs/errors"
 require "rbs/buffer"
 require "rbs/namespace"

data/schema/typeParam.json

@@ -15,13 +15,13 @@
     "upper_bound": {
       "oneOf": [
         {
-          "$ref": "types.json#definitions/classInstance"
+          "$ref": "types.json#/definitions/classInstance"
         },
         {
-          "$ref": "types.json#definitions/classSingleton"
+          "$ref": "types.json#/definitions/classSingleton"
         },
         {
-          "$ref": "types.json#definitions/interface"
+          "$ref": "types.json#/definitions/interface"
         },
         {
           "type": "null"

data/sig/annotate/annotations.rbs

@@ -0,0 +1,102 @@
+module RBS
+  module Annotate
+    class Annotations
+      type t = Skip | Source | Copy
+
+      def self.parse: (AST::Annotation) -> t?
+
+      attr_reader items: Array[t]
+
+      def initialize: (Array[t]) -> void
+
+      def skip?: () -> bool
+
+      def skip_all?: () -> bool
+
+      def test_path: (String path) -> bool
+
+      def test_path_string: (String pattern, String path) -> bool
+
+      def copy_annotation: -> Copy?
+
+      # Skip annotation allows skipping generating annotation of a subject.
+      #
+      #     %a{annotate:rdoc:skip}
+      #     %a{annotate:rdoc:skip:all}
+      #
+      class Skip
+        attr_reader annotation: AST::Annotation
+
+        attr_reader skip_children: bool
+
+        def initialize: (annotation: AST::Annotation, skip_children: bool) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Source annotation allows where the documents are copied from.
+      #
+      # It allows specifying two directions: the source to read from, and the source to skip.
+      #
+      #     %a{annotate:rdoc:source:from=ext/pathname}
+      #     %a{annotate:rdoc:source:skip=ext/pathname/doc}
+      #
+      # When you want to specify several paths, repeat writing the Source annotation.
+      #
+      class Source
+        attr_reader annotation: AST::Annotation
+
+        attr_reader include_source: String?
+        attr_reader skip_source: String?
+
+        def initialize: (annotation: AST::Annotation, include: String) -> void
+                      | (annotation: AST::Annotation, skip: String) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Copy annotation allows copying the doc from another subject.
+      # This helps working with incorrect RDoc annotations.
+      #
+      #     %a{annotate:rdoc:copy:Bar#baz}
+      #     %a{annotate:rdoc:copy:Bar.baz}
+      #     %a{annotate:rdoc:copy:Bar::Baz}
+      #
+      class Copy
+        attr_reader annotation: AST::Annotation
+
+        attr_reader source: String
+
+        def initialize: (annotation: AST::Annotation, source: String) -> void
+
+        # Returns a tuple of:
+        #
+        # - Type name
+        # - A pair of:
+        #   - Boolean which holds if it is singleton
+        #   - Name of method
+        def partition: () -> [TypeName, [bool, Symbol]?]
+
+        def type_name: () -> TypeName
+
+        def method_name: () -> Symbol?
+
+        def singleton?: () -> bool
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+    end
+  end
+end

data/sig/annotate/formatter.rbs

@@ -0,0 +1,24 @@
+module RBS
+  module Annotate
+    class Formatter
+      attr_reader buffer: String
+
+      @pending_separator: String?
+
+      def initialize: () -> void
+
+      def <<: (String | RDoc::Markup::Document | nil) -> self
+
+      def margin: (?separator: String) -> self
+
+      def empty?: () -> bool
+
+      def format: (newline_at_end: bool) -> String
+
+      def self.translate: (RDoc::Markup::Document) -> String?
+
+      def self.each_part: (RDoc::Markup::Document) { (RDoc::Markup::Document) -> void } -> void
+                        | (RDoc::Markup::Document) -> Enumerator[RDoc::Markup::Document, void]
+    end
+  end
+end

data/sig/annotate/rdoc_annotater.rbs

@@ -0,0 +1,82 @@
+module RBS
+  module Annotate
+    class RDocAnnotator
+      attr_reader source: RDocSource
+
+      attr_accessor include_arg_lists: bool
+      attr_accessor include_filename: bool
+
+      def initialize: (source: RDocSource) -> void
+
+      def annotate_file: (Pathname, preserve: bool) -> void
+
+      def annotate_decls: (Array[AST::Declarations::t], ?outer: Array[Namespace]) -> void
+
+      interface _PathTester
+        def test_path: (String) -> bool
+      end
+
+      interface _WithRDocComment
+        def comment: () -> RDoc::Markup::Document
+      end
+
+      def each_part: (Array[Object & _WithRDocComment], tester: _PathTester) { ([RDoc::Markup::Document, Object & _WithRDocComment]) -> void } -> void
+                   | (Array[Object & _WithRDocComment], tester: _PathTester) -> Enumerator[[RDoc::Markup::Document, Object & _WithRDocComment], void]
+
+      def join_docs: (Array[String?], ?separator: String) -> String?
+
+      def doc_for_class: (TypeName, tester: _PathTester) -> String?
+
+      # Returns the formatted document of given method.
+      #
+      # Expands attribute documents, or alias documents if needed.
+      #
+      def doc_for_method: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
+                        | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
+
+
+      def doc_for_method0: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
+                         | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
+
+      # Having `require: nil` means any attribute is okay.
+      # Having `require: "R"` means _read attr_ is required.
+      # Having `require: "W"` means write attr_ is required.
+      #
+      def doc_for_attribute: (TypeName, Symbol, singleton: bool, ?require: nil | "R" | "W", tester: _PathTester) -> String?
+
+      def doc_for_alias: (TypeName, name: Symbol, singleton: bool, tester: _PathTester) -> String?
+
+      def doc_for_constant: (TypeName, tester: _PathTester) -> String?
+
+      def resolve_doc_source: (Annotations::Copy?, tester: _PathTester) { () -> String? } -> String?
+
+      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, outer: Array[Namespace]) -> void
+
+      def annotate_constant: (AST::Declarations::Constant, outer: Array[Namespace]) -> void
+
+      def annotate_method: (TypeName, AST::Members::MethodDefinition) -> void
+
+      def annotate_alias: (TypeName, AST::Members::Alias) -> void
+
+      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor) -> void
+
+      def annotations: (_Annotated) -> Annotations
+
+      interface _Annotated
+        def annotations: -> Array[AST::Annotation]
+      end
+
+      # - If a string is given as `comment`, the content is attached to the object as a comment.
+      # - If empty string is given as `comment`, it deletes the original comment.
+      # - If `nil` is given as `comment`, it keeps the original comment.
+      #
+      def replace_comment: (Object & _Commented, String? comment) -> void
+
+      interface _Commented
+        def comment: () -> AST::Comment?
+      end
+
+      def resolve_name: (TypeName, outer: Array[Namespace]) -> TypeName
+    end
+  end
+end

data/sig/annotate/rdoc_source.rbs

@@ -0,0 +1,30 @@
+module RBS
+  module Annotate
+    class RDocSource
+      attr_accessor with_system_dir: bool
+      attr_accessor with_gems_dir: bool
+      attr_accessor with_site_dir: bool
+      attr_accessor with_home_dir: bool
+
+      attr_reader extra_dirs: Array[Pathname]
+
+      attr_reader stores: Array[RDoc::Store]
+
+      def initialize: () -> void
+
+      def load: () -> void
+
+      # Extract documents from `CodeObject`s
+      def docs: () { () -> Array[RDoc::CodeObject]? } -> Array[RDoc::Markup::Document]?
+
+      def find_class: (TypeName) -> Array[RDoc::ClassModule]?
+
+      def find_const: (TypeName) -> Array[RDoc::Constant]?
+
+      def find_method: (TypeName, instance_method: Symbol) -> Array[RDoc::AnyMethod]?
+                     | (TypeName, singleton_method: Symbol) -> Array[RDoc::AnyMethod]?
+
+      def find_attribute: (TypeName, Symbol, singleton: bool) -> Array[RDoc::Attr]?
+    end
+  end
+end

data/sig/buffer.rbs

@@ -11,12 +11,16 @@ module RBS
     # The content of the buffer.
     attr_reader content: String
 
-    attr_reader lines: Array[String]
+    @lines: Array[String]
 
-    attr_reader ranges: Array[Range[Integer]]
+    @ranges: Array[Range[Integer]]
 
     def initialize: (name: untyped name, content: String content) -> void
 
+    def lines: () -> Array[String]
+
+    def ranges: () -> Array[Range[Integer]]
+
     # Translate position to location.
     def pos_to_loc: (Integer pos) -> loc
 

data/sig/cli.rbs

@@ -66,6 +66,8 @@ module RBS
 
     def run_collection: (Array[String], LibraryOptions) -> void
 
+    def run_annotate: (Array[String], top) -> void
+
     def test_opt: (LibraryOptions) -> String?
 
     def collection_options: (Array[String]) -> OptionParser

data/sig/location.rbs

@@ -87,6 +87,12 @@ module RBS
     def each_required_key: () { (Symbol) -> void } -> void
                          | () -> Enumerator[Symbol, void]
 
+    def optional_key?: (Symbol) -> bool
+
+    def required_key?: (Symbol) -> bool
+
+    def key?: (Symbol) -> bool
+
     private
 
     def _start_loc: () -> Buffer::loc?

data/sig/members.rbs

@@ -12,6 +12,8 @@ module RBS
       class Base
       end
 
+      type visibility = :public | :private
+
       class MethodDefinition < Base
         type kind = :instance | :singleton | :singleton_instance
 
@@ -19,13 +21,14 @@ module RBS
         # ^^^                    keyword
         #     ^^^                name
         #
-        # def self.bar: () -> void | ...
-        # ^^^                              keyword
-        #     ^^^^^                        kind
-        #          ^^^                     name
-        #                            ^^^   overload
+        # private def self.bar: () -> void | ...
+        # ^^^^^^^                                  visibility
+        #         ^^^                              keyword
+        #             ^^^^^                        kind
+        #                  ^^^                     name
+        #                                    ^^^   overload
         #
-        type loc = Location[:keyword | :name, :kind | :overload]
+        type loc = Location[:keyword | :name, :kind | :overload | :visibility]
 
         attr_reader name: Symbol
         attr_reader kind: kind
@@ -34,8 +37,9 @@ module RBS
         attr_reader location: loc?
         attr_reader comment: Comment?
         attr_reader overload: bool
+        attr_reader visibility: visibility?
 
-        def initialize: (name: Symbol, kind: kind, types: Array[MethodType], annotations: Array[Annotation], location: loc?, comment: Comment?, overload: boolish) -> void
+        def initialize: (name: Symbol, kind: kind, types: Array[MethodType], annotations: Array[Annotation], location: loc?, comment: Comment?, overload: boolish, ?visibility: visibility?) -> void
 
         include _HashEqual
         include _ToJson
@@ -46,7 +50,7 @@ module RBS
 
         def overload?: () -> bool
 
-        def update: (?name: Symbol, ?kind: kind, ?types: Array[MethodType], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overload: boolish) -> MethodDefinition
+        def update: (?name: Symbol, ?kind: kind, ?types: Array[MethodType], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overload: boolish, ?visibility: visibility?) -> MethodDefinition
       end
 
       module Var
@@ -133,15 +137,16 @@ module RBS
         #             ^^^^             name
         #                 ^            colon
         #
-        # attr_accessor self.name (@foo) : String
-        # ^^^^^^^^^^^^^                             keyword
-        #               ^^^^^                       kind
-        #                    ^^^^                   name
-        #                         ^^^^^^            ivar
-        #                          ^^^^             ivar_name
-        #                                ^          colon
+        # public attr_accessor self.name (@foo) : String
+        # ^^^^^^                                           visibility
+        #        ^^^^^^^^^^^^^                             keyword
+        #                      ^^^^^                       kind
+        #                           ^^^^                   name
+        #                                ^^^^^^            ivar
+        #                                 ^^^^             ivar_name
+        #                                       ^          colon
         #
-        type loc = Location[:keyword | :name | :colon, :kind | :ivar | :ivar_name]
+        type loc = Location[:keyword | :name | :colon, :kind | :ivar | :ivar_name | :visibility]
 
         attr_reader name: Symbol
         attr_reader type: Types::t
@@ -150,12 +155,13 @@ module RBS
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
+        attr_reader visibility: visibility?
 
-        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, kind: kind, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, kind: kind, annotations: Array[Annotation], location: loc?, comment: Comment?, ?visibility: visibility?) -> void
 
         include _HashEqual
 
-        def update: (?name: Symbol, ?type: Types::t, ?ivar_name: Symbol | false | nil, ?kind: kind, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> instance
+        def update: (?name: Symbol, ?type: Types::t, ?ivar_name: Symbol | false | nil, ?kind: kind, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?visibility: visibility) -> instance
       end
 
       class AttrReader < Base

data/sig/method_builder.rbs

@@ -6,7 +6,8 @@ module RBS
 
         class Definition
           type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
-          type accessibility = :public | :private
+
+          type accessibility = RBS::Definition::accessibility
 
           attr_reader name: Symbol
           attr_reader type: instance_type
@@ -59,11 +60,11 @@ module RBS
 
       def build_interface: (TypeName) -> Methods
 
-      def build_alias: (Methods, Methods::instance_type, member: AST::Members::Alias, accessibility: Methods::Definition::accessibility) -> void
+      def build_alias: (Methods, Methods::instance_type, member: AST::Members::Alias) -> void
 
-      def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Methods::Definition::accessibility) -> void
+      def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Definition::accessibility) -> void
 
-      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Methods::Definition::accessibility) -> void
+      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Definition::accessibility) -> void
 
       def each_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
 

data/sig/method_types.rbs

@@ -7,7 +7,11 @@ module RBS
     # ^^^                      type_params
     #     ^^^^^^^^^^^^^^^^^^^  type
     #
-    type loc = Location[:type, :type_params]
+    type def_loc = Location[:type, :type_params]
+
+    type attr_loc = AST::Members::Attribute::loc
+
+    type loc = def_loc | attr_loc
 
     attr_reader type_params: Array[AST::TypeParam]
     attr_reader type: Types::Function

data/sig/polyfill.rbs

@@ -25,3 +25,81 @@ module Bundler
     def version: () -> String
   end
 end
+
+module RDoc
+  class Store
+    def initialize: (?String? path, ?Symbol? type) -> void
+
+    def find_class_or_module: (String) -> ClassModule?
+
+    def load_all: () -> void
+  end
+
+  module RI
+    module Paths
+      type path_type = :system | :site | :home | :gem | :extra
+
+      type gem_filter = :latest | :all
+
+      def self.each: (?bool system, ?bool site, ?bool home, ?gem_filter | false gems, *String extra_dirs) { (String, path_type) -> void } -> void
+    end
+  end
+
+  class CodeObject
+    def comment: () -> RDoc::Markup::Document
+  end
+
+  class Context < CodeObject
+
+  end
+
+  class ClassModule < Context
+    def constants: () -> Array[Constant]
+
+    def method_list: () -> Array[AnyMethod]
+
+    def attributes: () -> Array[Attr]
+  end
+
+  class Constant < CodeObject
+    def name: () -> String
+  end
+
+  class AnyMethod < MethodAttr
+    def arglists: () -> String?
+
+    def callseq: () -> String?
+  end
+
+  class MethodAttr < CodeObject
+    attr_reader name: String
+
+    attr_reader singleton: bool
+
+    attr_reader is_alias_for: MethodAttr?
+
+    attr_reader call_seq: String
+
+    attr_reader arglists: String
+  end
+
+  class Attr < MethodAttr
+    attr_accessor rw: "RW" | "R" | "W"
+  end
+
+  module Markup
+    class Document
+      include Enumerable[Document]
+
+      def each: () { (Document) -> void } -> void
+              | () -> Enumerator[Document, void]
+
+      def file: () -> String?
+
+      def accept: (untyped) -> String
+    end
+
+    class ToMarkdown
+    end
+  end
+end

data/sig/validator.rbs

@@ -23,7 +23,9 @@ module RBS
     # - The generics type parameter variance annotation is consistent with respect to their usage
     # - There is no circular dependencies between the generics type parameter bounds
     #
-    def validate_type_alias: (entry: Environment::SingleEntry[TypeName, AST::Declarations::Alias]) -> void
+    # It yields the rhs type if block is given, so that you can validate the rhs type.
+    #
+    def validate_type_alias: (entry: Environment::SingleEntry[TypeName, AST::Declarations::Alias]) ?{ (Types::t rhs_type) -> void } -> void
 
     # Validates the type parameters in generic methods.
     #