rbs 4.1.0.pre.2-java

data/sig/location.rbs

@@ -0,0 +1,135 @@
+module RBS
+  # Location is the range on buffer, `start_pos..end_pos`.
+  # The index is based on characters.
+  #
+  # A location can have _child_ locations.
+  #
+  class Location[in RequiredChildKeys = untyped, in OptionalChildKeys = untyped]
+    # The buffer this location points on.
+    attr_reader buffer (): Buffer
+
+    # The absolute start index of character the range starts from
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
+    attr_reader start_pos (): Integer
+
+    # The absolute end index of character the range ends at
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
+    attr_reader end_pos (): Integer
+
+    def initialize: (Buffer, Integer start_pos, Integer end_pos) -> void
+
+    def self.new: (Buffer, Integer start_pos, Integer end_pos) -> instance
+                | (buffer: Buffer, start_pos: Integer, end_pos: Integer) -> instance
+
+    def inspect: () -> String
+
+    # Returns the name of the buffer.
+    def name: () -> untyped
+
+    # The *raw* index of character the range starts from.
+    attr_reader _start_pos (): Integer
+
+    # The *raw* index of character the range ends at.
+    attr_reader _end_pos (): Integer
+
+    # Line of the `start_pos` (1 origin, absolute)
+    attr_reader start_line (): Integer
+
+    # Column of the `start_pos` (0 origin, absolute)
+    attr_reader start_column (): Integer
+
+    # Line of the `end_pos` (1 origin, absolute)
+    attr_reader end_line (): Integer
+
+    # Column of the `end_pos` (0 origin, absolute)
+    attr_reader end_column (): Integer
+
+    # The absolute line-column pair of the start position
+    #
+    attr_reader start_loc (): Buffer::loc
+
+    @start_loc: Buffer::loc?
+
+    # The absolute line-column pair of the end position
+    #
+    attr_reader end_loc (): Buffer::loc
+
+    @end_loc: Buffer::loc?
+
+    # The absolute range of the start and end position
+    attr_reader range (): Range[Integer]
+
+    @range: Range[Integer]?
+
+    # A substring of buffer associated to the location.
+    def source: () -> String
+
+    @source: String?
+
+    def to_s: () -> String
+
+    # Returns a string representation suitable for terminal output.
+    #
+    #     Location.to_string(loc)  # => a.rb:1:0...3:4
+    #     Location.to_string(nil)  # => *:*:*..*:*
+    #
+    def self.to_string: (Location[untyped, untyped]? location, ?default: ::String default) -> String
+
+    def ==: (untyped other) -> bool
+
+    include _ToJson
+
+    def add_optional_child: (OptionalChildKeys name, Range[Integer]? range) -> void
+
+    def add_required_child: (RequiredChildKeys name, Range[Integer] range) -> void
+
+    # Returns `Location` instance for given _child_ name.
+    #
+    #     # @type var loc: Location::WithChildren[:name, :args]
+    #     loc[:name]      # => Location
+    #     loc[:args]      # => may be nil
+    #
+    # Note that passing unknown symbol raises an error even if the child is _optional_.
+    # You need explicitly set `nil` for absent optional children.
+    #
+    def []: (RequiredChildKeys) -> Location[bot, bot]
+          | (OptionalChildKeys) -> Location[bot, bot]?
+          | (Symbol) -> Location[bot, bot]?
+
+    alias aref []
+
+    def each_optional_key: () { (Symbol) -> void } -> void
+                         | () -> Enumerator[Symbol, void]
+
+    def each_required_key: () { (Symbol) -> void } -> void
+                         | () -> Enumerator[Symbol, void]
+
+    def optional_key?: (Symbol) -> bool
+
+    def required_key?: (Symbol) -> bool
+
+    def key?: (Symbol) -> bool
+
+    # Returns the location of the buffer, but the buffer is detached from the parent buffer
+    #
+    def local_location: () -> self
+
+    # Returns the source of `#local_location`
+    # 
+    def local_source: () -> String
+
+    private
+
+    def _add_required_child: (RequiredChildKeys name, Integer start_pos, Integer end_pos) -> void
+    def _add_optional_child: (OptionalChildKeys name, Integer start_pos, Integer end_pos) -> void
+    def _add_optional_no_child: (OptionalChildKeys name) -> void
+    def _optional_keys: () -> Array[Symbol]
+    def _required_keys: () -> Array[Symbol]
+
+    WithChildren: singleton(Location)
+  end
+end

data/sig/locator.rbs

@@ -0,0 +1,56 @@
+module RBS
+  # Locator helps finding RBS elements based on locations in the RBS source text.
+  #
+  class Locator
+    type component = Symbol
+                   | Types::t
+                   | MethodType
+                   | AST::Declarations::t
+                   | AST::Members::t
+                   | AST::TypeParam
+                   | AST::Declarations::Class::Super
+                   | AST::Declarations::Module::Self
+                   | AST::Directives::t
+                   | AST::Directives::Use::clause
+
+    # The buffer the location points to
+    #
+    attr_reader buffer: Buffer
+
+    # Array of _top-level_ declarations.
+    #
+    attr_reader decls: Array[AST::Declarations::t]
+
+    # Array of directives.
+    #
+    attr_reader dirs: Array[AST::Directives::t]
+
+    def initialize: (buffer: Buffer, decls: Array[AST::Declarations::t], dirs: Array[AST::Directives::t]) -> void
+
+    # Returns list of components.
+    # Inner component comes first.
+    #
+    def find: (line: Integer, column: Integer) -> Array[component]
+
+    # Returns pair of the inner most symbol and outer components.
+    # It ensures the array starts with a AST/type component.
+    #
+    def find2: (line: Integer, column: Integer) -> [Symbol?, Array[component]]?
+
+    def find_in_directive: (Integer pos, AST::Directives::t, Array[component]) -> bool
+
+    def find_in_decl: (Integer pos, decl: AST::Declarations::t, array: Array[component]) -> bool
+
+    def find_in_member: (Integer pos, member: AST::Members::t, array: Array[component]) -> bool
+
+    def find_in_method_type: (Integer pos, method_type: MethodType, array: Array[component]) -> bool
+
+    def find_in_type: (Integer pos, type: Types::t, array: Array[component]) -> bool
+
+    def find_in_type_param: (Integer pos, type_param: AST::TypeParam, array: Array[component]) -> bool
+
+    def find_in_loc: (Integer pos, location: Location[untyped, untyped]?, array: Array[component]) -> bool
+
+    def test_loc: (Integer pos, location: Location[untyped, untyped]?) -> bool
+  end
+end

data/sig/manifest.yaml

@@ -0,0 +1,5 @@
+dependencies:
+  - name: json
+  - name: optparse
+  - name: tsort
+  - name: rdoc

data/sig/members.rbs

@@ -0,0 +1,258 @@
+module RBS
+  module AST
+    module Members
+      type t = MethodDefinition
+             | InstanceVariable | ClassInstanceVariable | ClassVariable
+             | Include | Extend | Prepend
+             | AttrReader | AttrWriter | AttrAccessor
+             | Public | Private
+             | Alias
+
+      # Base class for members.
+      class Base
+      end
+
+      type visibility = :public | :private
+
+      class MethodDefinition < Base
+        class Overload
+          attr_reader method_type: MethodType
+
+          attr_reader annotations: Array[Annotation]
+
+          def initialize: (method_type: MethodType, annotations: Array[Annotation]) -> void
+
+          def ==: (untyped) -> bool
+
+          def hash: () -> Integer
+
+          alias eql? ==
+
+          def update: (?annotations: Array[Annotation], ?method_type: MethodType) -> Overload
+
+          def sub: (Substitution) -> Overload
+
+          include _ToJson
+        end
+
+        type kind = :instance | :singleton | :singleton_instance
+
+        # def foo: () -> void
+        # ^^^                    keyword
+        #     ^^^                name
+        #
+        # private def self.bar: () -> void | ...
+        # ^^^^^^^                                  visibility
+        #         ^^^                              keyword
+        #             ^^^^^                        kind
+        #                  ^^^                     name
+        #                                    ^^^   overloading
+        #
+        type loc = Location[:keyword | :name, :kind | :overloading | :visibility]
+
+        attr_reader name: Symbol
+        attr_reader kind: kind
+        attr_reader overloads: Array[Overload]
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: loc?
+        attr_reader comment: Comment?
+        attr_reader overloading: bool
+        attr_reader visibility: visibility?
+
+        def initialize: (name: Symbol, kind: kind, overloads: Array[Overload], annotations: Array[Annotation], location: loc?, comment: Comment?, overloading: bool, visibility: visibility?) -> void
+
+        include _HashEqual
+        include _ToJson
+
+        # Returns true if the `def` is to define instance method
+        def instance?: () -> bool
+
+        # Returns true if the `def` is to define singleton method
+        def singleton?: () -> bool
+
+        # Returns true if the `def` is overloading (== with `...`)
+        #
+        def overloading?: () -> bool
+
+        def update: (?name: Symbol, ?kind: kind, ?overloads: Array[Overload], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overloading: bool, ?visibility: visibility?) -> MethodDefinition
+      end
+
+      module Var
+        # @foo: String
+        # ^^^^            name
+        #     ^           colon
+        #
+        # self.@all: Array[String]
+        # ^^^^^                        kind
+        #      ^^^^                    name
+        #          ^                   colon
+        #
+        type loc = Location[:name | :colon, :kind]
+
+        attr_reader name: Symbol
+        attr_reader type: Types::t
+        attr_reader location: loc?
+        attr_reader comment: Comment?
+
+        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+      end
+
+      class InstanceVariable < Base
+        include Var
+        include _ToJson
+      end
+
+      class ClassInstanceVariable < Base
+        include Var
+        include _ToJson
+      end
+
+      class ClassVariable < Base
+        include Var
+        include _ToJson
+      end
+
+      module Mixin
+        # include Foo
+        # ^^^^^^^       keyword
+        #         ^^^   name
+        #
+        # include Array[String]
+        # ^^^^^^^                keyword
+        #         ^^^^^          name
+        #              ^^^^^^^^  args
+        #
+        type loc = Location[:name | :keyword, :args]
+
+        attr_reader name: TypeName
+        attr_reader args: Array[Types::t]
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: loc?
+        attr_reader comment: Comment?
+
+        def initialize: (name: TypeName, args: Array[Types::t], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+      end
+
+      class Include < Base
+        include Mixin
+        include _ToJson
+      end
+
+      class Extend < Base
+        include Mixin
+        include _ToJson
+      end
+
+      class Prepend < Base
+        include Mixin
+        include _ToJson
+      end
+
+      module Attribute
+        type kind = :instance | :singleton
+
+        # attr_reader name: String
+        # ^^^^^^^^^^^                  keyword
+        #             ^^^^             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 | :visibility]
+
+        attr_reader name: Symbol
+        attr_reader type: Types::t
+        attr_reader kind: kind
+        attr_reader ivar_name: Symbol | false | nil
+        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?, ?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?, ?visibility: visibility?) -> instance
+      end
+
+      class AttrReader < Base
+        include Attribute
+        include _ToJson
+      end
+
+      class AttrAccessor < Base
+        include Attribute
+        include _ToJson
+      end
+
+      class AttrWriter < Base
+        include Attribute
+        include _ToJson
+      end
+
+      module LocationOnly
+        attr_reader location: Location[bot, bot]?
+
+        def initialize: (location: Location[bot, bot]?) -> void
+
+        include _HashEqual
+      end
+
+      class Public < Base
+        include LocationOnly
+        include _ToJson
+      end
+
+      class Private < Base
+        include LocationOnly
+        include _ToJson
+      end
+
+      class Alias < Base
+        type kind = :instance | :singleton
+
+        # alias foo bar
+        # ^^^^^           keyword
+        #       ^^^       new_name
+        #           ^^^   old_name
+        #
+        # alias self.foo self.bar
+        # ^^^^^                      keyword
+        #       ^^^^^                new_kind
+        #            ^^^             new_name
+        #                ^^^^^       old_kind
+        #                     ^^^    old_name
+        #
+        type loc = Location[:keyword | :new_name | :old_name, :new_kind | :old_kind]
+
+        attr_reader new_name: Symbol
+        attr_reader old_name: Symbol
+        attr_reader kind: kind
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: loc?
+        attr_reader comment: Comment?
+
+        def initialize: (new_name: Symbol, old_name: Symbol, kind: kind, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+
+        def instance?: () -> bool
+
+        def singleton?: () -> bool
+      end
+    end
+  end
+end

data/sig/method_builder.rbs

@@ -0,0 +1,89 @@
+module RBS
+  class DefinitionBuilder
+    # MethodBuilder calculates the sequence of methods available on given type
+    #
+    # The sequence are sorted topologically.
+    #
+    class MethodBuilder
+      # Set of methods defined in a type.
+      #
+      class Methods
+        type instance_type = Types::ClassInstance | Types::ClassSingleton | Types::Interface
+
+        # Definition of a method in the type
+        #
+        # The Definition object allows invalid method definition so that more than one _original_ definitions may exist.
+        #
+        class Definition
+          type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
+                        | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
+
+          type overloading_definition = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
+
+          type accessibility = RBS::Definition::accessibility
+
+          attr_reader name: Symbol
+          attr_reader type: instance_type
+          attr_reader originals: Array[original]
+          attr_reader overloads: Array[overloading_definition]
+          attr_reader accessibilities: Array[accessibility]
+
+          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[overloading_definition], accessibilities: Array[accessibility]) -> void
+
+          def original: () -> original?
+
+          def accessibility: () -> accessibility
+
+          def self.empty: (name: Symbol, type: instance_type) -> Definition
+        end
+
+        attr_reader type: instance_type
+        attr_reader methods: Hash[Symbol, Definition]
+
+        def initialize: (type: instance_type) -> void
+
+        def validate!: () -> self
+
+        def each: () { (Definition) -> void } -> void
+                | () -> Enumerator[Definition, void]
+
+        class Sorter
+          include TSort[Definition]
+
+          attr_reader methods: Hash[Symbol, Definition]
+
+          def initialize: (Hash[Symbol, Definition]) -> void
+
+          def tsort_each_node: { (Definition) -> void } -> void
+
+          def tsort_each_child: (Definition) { (Definition) -> void } -> void
+        end
+      end
+
+      attr_reader env: Environment
+      attr_reader instance_methods: Hash[TypeName, Methods]
+      attr_reader singleton_methods: Hash[TypeName, Methods]
+      attr_reader interface_methods: Hash[TypeName, Methods]
+
+      def initialize: (env: Environment) -> void
+
+      def build_instance: (TypeName) -> Methods
+
+      def build_singleton: (TypeName) -> Methods
+
+      def build_interface: (TypeName) -> Methods
+
+      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: Definition::accessibility) -> void
+
+      def build_ruby_attribute: (Methods, Methods::instance_type, member: AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember, accessibility: Definition::accessibility) -> void
+
+      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition | AST::Ruby::Members::DefMember, accessibility: Definition::accessibility) -> void
+
+      def each_rbs_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
+
+      def update: (env: Environment, except: _Each[TypeName]) -> MethodBuilder
+    end
+  end
+end

data/sig/method_types.rbs

@@ -0,0 +1,58 @@
+module RBS
+  class MethodType
+    # () -> void
+    # ^^^^^^^^^^     type
+    #
+    # [A] () { () -> A } -> A
+    # ^^^                      type_params
+    #     ^^^^^^^^^^^^^^^^^^^  type
+    #
+    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
+    attr_reader block: Types::Block?
+    attr_reader location: loc?
+
+    def initialize: (type_params: Array[AST::TypeParam], type: Types::function, block: Types::Block?, location: loc?) -> void
+
+    def ==: (untyped other) -> bool
+
+    include _ToJson
+
+    # Substitute type variables to some types.
+    # Takes care of type parameter bounds.
+    #
+    def sub: (Substitution) -> MethodType
+
+    def update: (?type_params: Array[AST::TypeParam], ?type: Types::function, ?block: Types::Block?, ?location: loc?) -> MethodType
+
+    def free_variables: (?Set[Symbol] set) -> Set[Symbol]
+
+    # Apply the mapping included in the MethodType.
+    #
+    # Note that type bound in generics parameter is not handled by this method.
+    # You may want to use `#map_type_bound` explicitly, or `#sub` for simple substitution.
+    #
+    def map_type: () { (Types::t) -> Types::t } -> MethodType
+
+    def map_type_bound: () { (Types::t) -> Types::t } -> MethodType
+
+    def each_type: () { (Types::t) -> void } -> void
+                 | () -> Enumerator[Types::t, void]
+
+    def to_s: () -> String
+
+    def type_param_names: () -> Array[Symbol]
+
+    def has_self_type?: () -> bool
+
+    def has_classish_type?: () -> bool
+
+    def with_nonreturn_void?: () -> bool
+  end
+end