rbs-relaxed 3.9.0.1

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,84 @@
+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
+
+          type accessibility = RBS::Definition::accessibility
+
+          attr_reader name: Symbol
+          attr_reader type: instance_type
+          attr_reader originals: Array[original]
+          attr_reader overloads: Array[AST::Members::MethodDefinition]
+          attr_reader accessibilities: Array[accessibility]
+
+          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[AST::Members::MethodDefinition], 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_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
+
+      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

data/sig/namespace.rbs

@@ -0,0 +1,146 @@
+module RBS
+  # Namespace instance represents a _prefix of module names_.
+  #
+  # ```
+  # vvvvvvvvvvvvvv  TypeName
+  # RBS::Namespace
+  # ^^^^^           Namespace
+  #
+  # vvvvvvvvvv    TypeName
+  # RBS::Types
+  # ^^^^^         Namespace
+  #
+  # vvvvvvvvvvvvvvvvv    TypeName
+  # RBS::Types::Union
+  # ^^^^^^^^^^^^         Namespace
+  # ```
+  #
+  # Note that `Namespace` is an RBS specific concept and there is no corresponding concept in Ruby.
+  #
+  # There are _absolute_ and _relative_ namespaces.
+  #
+  # ```
+  # Namespace(::RBS::)         # Absolute namespace
+  # Namespace(  RBS::)         # Relative namespace
+  # ```
+  #
+  # It also defines two special namespaces.
+  #
+  # ```
+  # ::              # _Root_ namespace
+  #                 # _Empty_ namespace
+  # ```
+  #
+  class Namespace
+    attr_reader path: Array[Symbol]
+
+    def initialize: (path: Array[Symbol], absolute: boolish) -> void
+
+    @absolute: bool
+
+    @parent: Namespace?
+
+    self.@root: Namespace?
+
+    self.@empty: Namespace?
+
+    # Returns new _empty_ namespace.
+    def self.empty: () -> Namespace
+
+    # Returns new _root_ namespace.
+    def self.root: () -> Namespace
+
+    # Concat two namespaces.
+    #
+    # ```rb
+    # Namespace("Foo::") + Namespace("Bar::")   # => Foo::Bar::
+    # Namespace("::Foo::") + Namespace("Bar::") # => ::Foo::Bar::
+    # ```
+    #
+    # If `other` is an absolute namespace, it returns `other`.
+    #
+    # ```rb
+    # Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
+    # ```
+    def +: (Namespace other) -> Namespace
+
+    # Add one path component to self.
+    #
+    # ```rb
+    # Namespace("Foo::").append(:Bar) # => Namespace("Foo::Bar::")
+    # ```
+    def append: (Symbol component) -> Namespace
+
+    # Returns parent namespace.
+    # Raises error there is no parent namespace.
+    #
+    # ```rb
+    # Namespace("::A").parent    # => Namespace("::")
+    # Namespace("::").parent     # raises error
+    # Namespace("A::B").parent   # => Namespace("A")
+    # ```
+    def parent: () -> Namespace
+
+    # Returns true if self is absolute namespace.
+    def absolute?: () -> bool
+
+    # Returns true if self is relative namespace.
+    def relative?: () -> bool
+
+    # Returns absolute namespace.
+    #
+    # ```rb
+    # Namespace("A").absolute!      # => Namespace("::A")
+    # Namespace("::A").absolute!    # => Namespace("::A")
+    # ```
+    def absolute!: () -> Namespace
+
+    # Returns _relative_ namespace.
+    #
+    def relative!: () -> Namespace
+
+    def empty?: () -> bool
+
+    # Equality is defined by its structure.
+    #
+    def ==: (untyped other) -> bool
+
+    alias eql? ==
+
+    # Hash is defined based on its structure.
+    #
+    def hash: () -> Integer
+
+    # Returns a pair of parent namespace and a symbol of last component.
+    #
+    # ```rb
+    # Namespace("::A::B::C").split    # => [Namespace("::A::B::"), :C]
+    # ```
+    def split: () -> [Namespace, Symbol]?
+
+    def to_s: () -> String
+
+    # Construct a type name which points to the same name type.
+    #
+    def to_type_name: () -> TypeName
+
+    def self.parse: (String string) -> Namespace
+
+    # Iterate over Namespace for each element in ascending order.
+    #
+    # ```rb
+    # Namespace.parse("::A::B::C").ascend {|ns| p ns }
+    #   # => ::A::B::C
+    #   # => ::A::B
+    #   # => ::A
+    #   # => ::(root)
+    # ```
+    def ascend: () { (Namespace) -> void } -> void
+              | () -> Enumerator[Namespace, void]
+  end
+end
+
+module Kernel
+  # Deprecated: Use `RBS::Namespace.parse` instead
+  %a{steep:deprecated} def Namespace: (String) -> RBS::Namespace
+end

data/sig/parser.rbs

@@ -0,0 +1,100 @@
+module RBS
+  class Parser
+    # Result of `Parser.lex`
+    class LexResult
+      attr_reader buffer: Buffer
+      attr_reader value: Array[Token]
+
+      def initialize: (buffer: Buffer, value: Array[Token]) -> void
+    end
+
+    # Represents a token per result of `Parser.lex`.
+    class Token
+      attr_reader type: Symbol
+      attr_reader location: Location[untyped, untyped]
+
+      def initialize: (type: Symbol, location: Location[untyped, untyped]) -> void
+      def value: () -> String
+      def comment?: () -> bool
+    end
+
+    # Parse a method type and return it
+    #
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
+    #
+    # ```ruby
+    # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void", range: 0...)                   # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void () -> String", range: 11...)     # => `() -> String`
+    # RBS::Parser.parse_method_type("() -> void () -> String", range: 23...)     # => nil
+    # ```
+    #
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: false)    # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_method_type("", require_eof: true)                            # => nil
+    # ```
+    #
+    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
+
+    # Parse a type and return it
+    #
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("String")                          # => `String`
+    # RBS::Parser.parse_type("String", range: 0...)             # => `String`
+    # RBS::Parser.parse_type("String Integer", pos: 7...)       # => `Integer`
+    # RBS::Parser.parse_type("String Integer", pos: 14...)      # => nil
+    # ```
+    #
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("String untyped", require_eof: false)    # => `String`
+    # RBS::Parser.parse_type("String untyped", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_type("", require_eof: true)                   # => nil
+    # ```
+    #
+    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> Types::t?
+
+    # Parse whole RBS file and return an array of declarations
+    #
+    def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
+
+    # Returns the magic comment from the buffer
+    #
+    def self.magic_comment: (Buffer) -> AST::Directives::ResolveTypeNames?
+
+    # Parse whole RBS file and return result.
+    #
+    # ```ruby
+    # RBS::Parser.lex("# Comment\nmodule A\nend\n").value.map(&:type)
+    # # => [:tLINECOMMENT, :kMODULE, :tUIDENT, :kEND, :pEOF]
+    # ```
+    def self.lex: (Buffer | String) -> LexResult
+
+    KEYWORDS: Hash[String, bot]
+
+    private
+
+    def self.buffer: (String | Buffer source) -> Buffer
+
+    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> Types::t?
+
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
+
+    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+
+    def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
+
+    class LocatedValue
+    end
+  end
+end

data/sig/prototype/helpers.rbs

@@ -0,0 +1,27 @@
+module RBS
+  module Prototype
+    module Helpers
+      type node = RubyVM::AbstractSyntaxTree::Node
+
+      def block_from_body: (node) -> Types::Block?
+
+      def each_node: (Array[untyped] nodes) { (node) -> void } -> void
+
+      def each_child: (node) { (node child) -> void } -> void
+
+      def any_node?: (node, ?nodes: Array[node]) { (node) -> bool } -> Array[node]?
+
+      def keyword_hash?: (node) -> bool
+
+      # Returns a symbol if the node is a symbol literal node
+      # 
+      def symbol_literal_node?: (node) -> Symbol?
+
+      def args_from_node: (node?) -> Array[untyped]
+
+      def untyped: () -> Types::Bases::Any
+
+      @untyped: Types::Bases::Any
+    end
+  end
+end

data/sig/prototype/node_usage.rbs

@@ -0,0 +1,20 @@
+module RBS
+  module Prototype
+    class NodeUsage
+      include Helpers
+      
+      type node = RubyVM::AbstractSyntaxTree::Node
+
+      attr_reader node: node
+
+      attr_reader conditional_nodes: Set[node]
+
+      def initialize: (node) -> void
+
+      def calculate: (node, conditional: bool) -> void
+
+      def each_conditional_node: () { (node) -> void } -> void
+                               | () -> Enumerator[node, void]
+    end
+  end
+end