rbs-relaxed 3.9.0.1

data/sig/shims/bundler.rbs

@@ -0,0 +1,38 @@
+module Bundler
+  class LockfileParser
+    def initialize: (String) -> void
+
+    def specs: () -> Array[LazySpecification]
+  end
+
+  class LazySpecification
+    def name: () -> String
+
+    def version: () -> String
+
+    def dependencies: () -> Array[Gem::Dependency]
+  end
+
+  class Dependency < Gem::Dependency
+    attr_reader autorequire: Array[String]?
+
+    attr_reader source: untyped
+  end
+
+  class Definition
+    def lockfile: () -> Pathname
+
+    def locked_gems: () -> LockfileParser
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  def self.default_lockfile: () -> Pathname
+
+  def self.definition: () -> Definition
+
+  module Source
+    class Gemspec
+    end
+  end
+end

data/sig/shims/enumerable.rbs

@@ -0,0 +1,5 @@
+module Enumerable[unchecked out Elem] : _Each[Elem]
+  def each_slice: (2) { ([Elem, Elem]) -> void } -> void
+                | (2) -> Enumerator[[Elem, Elem], void]
+                | ...
+end

data/sig/shims/rubygems.rbs

@@ -0,0 +1,19 @@
+module Gem
+  class Specification
+    attr_reader version (): Version
+
+    attr_reader gem_dir (): String
+
+    def self.find_by_name: (String name, *String requirements) -> instance
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  class Dependency
+    def name: () -> String
+  end
+
+  module ::Kernel
+    def self?.gem: (String, *String) -> void
+  end
+end

data/sig/sorter.rbs

@@ -0,0 +1,41 @@
+module RBS
+  class Sorter
+    include RBS::AST
+
+    type member = AST::Declarations::Class::member
+                | AST::Declarations::Module::member
+                | AST::Declarations::Interface::member
+
+    attr_reader path: Pathname
+
+    attr_reader stdout: IO
+
+    def initialize: (Pathname path, ?stdout: IO) -> void
+
+    def run: () -> void
+
+    type partitioned = {
+      type_alias_decls: Array[AST::Declarations::TypeAlias],
+      constant_decls: Array[AST::Declarations::Constant],
+      class_decls: Array[AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface],
+      mixin_includes: Array[AST::Members::Include],
+      mixin_prepends: Array[AST::Members::Prepend],
+      mixin_extends: Array[AST::Members::Extend],
+      class_variables: Array[AST::Members::ClassVariable],
+      class_instance_variables: Array[AST::Members::ClassInstanceVariable],
+      instance_variables: Array[AST::Members::InstanceVariable],
+      singleton_attributes: Array[AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader],
+      instance_attributes: Array[AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader],
+      module_functions: Array[AST::Members::MethodDefinition],
+      singleton_new_methods: Array[AST::Members::MethodDefinition],
+      public_singleton_methods: Array[AST::Members::MethodDefinition | AST::Members::Alias],
+      private_singleton_methods: Array[AST::Members::MethodDefinition],
+      instance_initialize_methods: Array[AST::Members::MethodDefinition],
+      public_instance_methods: Array[AST::Members::MethodDefinition | AST::Members::Alias],
+      private_instance_methods: Array[AST::Members::MethodDefinition],
+      other_decls: Array[member]
+    }
+
+    def sort_decl: (member decl) -> member
+  end
+end

data/sig/substitution.rbs

@@ -0,0 +1,48 @@
+module RBS
+  # Substitution from type variables to types.
+  #
+  # The substitution construction is in _destructive_ manner.
+  #
+  #    sub = Substitution.new
+  #    sub.add(from: :A, to: type1)
+  #    sub.add(from: :B, to: type2)
+  #    sub.instance_type = type3
+  #
+  class Substitution
+    # A hash containing mapping from type variable name to type.
+    attr_reader mapping: Hash[Symbol, Types::t]
+
+    # The result of applying this substitution to `instance` type.
+    # `nil` maps to `instance` type itself.
+    attr_accessor instance_type: Types::t?
+
+    def initialize: () -> void
+
+    # Add mapping to this substitution.
+    # Overwrites the previous mapping if same `from` is given.
+    def add: (from: Symbol, to: Types::t) -> void
+
+    # Utility method to construct a substitution.
+    # Raises an error when `variables.size != types.size`.
+    # `instance_type` defaults to `nil`.
+    #
+    # Yields types in `types` and the block value is used if block is given.
+    #
+    def self.build: (Array[Symbol] variables, Array[Types::t] types, ?instance_type: Types::t?) ?{ (Types::t) -> Types::t } -> instance
+
+    # Applies the substitution to given type.
+    def apply: (Types::t) -> Types::t
+
+    # Returns a substitution without variables given in `vars`.
+    def without: (*Symbol vars) -> Substitution
+
+    # Returns true if given substitution is identity.
+    def empty?: () -> bool
+
+    alias [] apply
+
+    # (s1 + s2)[t] == s2[s1[t]]
+    # 
+    def +: (Substitution) -> Substitution
+  end
+end

data/sig/subtractor.rbs

@@ -0,0 +1,37 @@
+module RBS
+  class Subtractor
+    type decl_with_members = AST::Declarations::Class | AST::Declarations::Module
+
+    @minuend: Array[AST::Declarations::t]
+    @subtrahend: Environment
+
+    def initialize: (Array[AST::Declarations::t] minuend, Environment subtrahend) -> void
+
+    def call: (?Array[AST::Declarations::t], ?context: Resolver::context) -> Array[AST::Declarations::t]
+
+    private def filter_members: (decl_with_members, context: Resolver::context) -> decl_with_members?
+
+    private def member_exist?: (TypeName owner, AST::Members::t, context: Resolver::context) -> boolish
+
+    private def method_exist?: (TypeName owner, Symbol method_name, AST::Members::MethodDefinition::kind) -> boolish
+
+    private def ivar_exist?: (TypeName owner, Symbol ivar_name, AST::Members::Attribute::kind) -> boolish
+
+    private def cvar_exist?: (TypeName owner, Symbol cvar_name) -> boolish
+
+    private def each_member: (TypeName owner) { (AST::Members::t | AST::Declarations::t) -> void } -> void
+                           | (TypeName owner) -> Enumerator[(AST::Members::t | AST::Declarations::t), void]
+
+    private def mixin_exist?: (TypeName owner, AST::Members::Include | AST::Members::Extend | AST::Members::Prepend, context: Resolver::context) -> boolish
+
+    private def filter_redundant_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
+
+    private def access_modifier?: (AST::Declarations::t | AST::Members::t?) -> bool
+
+    private def update_decl: (decl_with_members, members: Array[AST::Declarations::t | AST::Members::t]) -> decl_with_members
+
+    private def absolute_typename: (TypeName, context: Resolver::context) -> TypeName
+
+    private def typename_candidates: (TypeName, context: Resolver::context) -> Array[TypeName]
+  end
+end

data/sig/test/errors.rbs

@@ -0,0 +1,52 @@
+module RBS
+  module Test
+    module Errors
+      type t = ArgumentTypeError | BlockArgumentError | ArgumentError | BlockArgumentError | ReturnTypeError | BlockReturnTypeError
+             | UnexpectedBlockError | MissingBlockError | UnresolvedOverloadingError
+
+      # Type of a argument value given to a method call is not compatible with the type from method type
+      class ArgumentTypeError
+      end
+
+      # Type of a argument value given to a block yield is not compatible with the type from method type
+      class BlockArgumentTypeError
+      end
+
+      # Incompatible number of args/keyword args is given to a method call
+      class ArgumentError
+      end
+
+      # Incompatible number of args is given to a block yield
+      class BlockArgumentError
+      end
+
+      # Type of return value from a method call is incompatible
+      class ReturnTypeError
+      end
+
+      # Type of return value from a block yield is incompatible
+      class BlockReturnTypeError
+      end
+
+      # Unexpected block is given
+      class UnexpectedBlockError
+      end
+
+      # Required block is missing
+      class MissingBlockError
+      end
+
+      # Any other error
+      class UnresolvedOverloadingError
+      end
+
+      def self.format_param: (Types::Function::Param) -> String
+
+      RESPOND_TO: UnboundMethod
+
+      def self.inspect_: (untyped) -> String
+
+      def self.to_string: (t) -> String
+    end
+  end
+end

data/sig/test/guranteed.rbs

@@ -0,0 +1,9 @@
+module RBS
+  module Test
+    module Guaranteed
+      module Inspect
+        def self?.guaranteed_inspect: (untyped) -> String
+      end
+    end
+  end
+end

data/sig/test/type_check.rbs

@@ -0,0 +1,19 @@
+module RBS
+  module Test
+    class TypeCheck
+      def initialize: (self_class: Module, builder: DefinitionBuilder, sample_size: Integer, unchecked_classes: Array[Module], instance_class: Module, class_class: Module) -> void
+
+      # Confirm if given `CallTrace` is compatible with `MethodType`
+      #
+      # Returns an array with detected errors.
+      #
+      def method_call: (Symbol, MethodType, CallTrace, errors: Array[Errors::t], ?annotations: Array[AST::Annotation]) -> Array[Errors::t]
+
+      # Test if given `value` is compatible to type
+      #
+      # Returns `true` if the value has the type.
+      #
+      def value: (untyped value, Types::t) -> bool
+    end
+  end
+end

data/sig/test.rbs

@@ -0,0 +1,82 @@
+module RBS
+  module Test
+    # Object#class
+    CLASS: UnboundMethod
+
+    # Module#define_method
+    DEFINE_METHOD: UnboundMethod
+
+    # Kernel#inspect
+    INSPECT: UnboundMethod
+
+    # BasicObject#instance_eval
+    INSTANCE_EVAL: UnboundMethod
+
+    # BasicObject#instance_exec
+    INSTANCE_EXEC: UnboundMethod
+
+    # Kernel#is_a?
+    IS_AP: UnboundMethod
+
+    # Kernel#method
+    METHOD: UnboundMethod
+
+    # Kernel#methods
+    METHODS: UnboundMethod
+
+    # Kernel#pp
+    PP: UnboundMethod
+
+    # Kernel#singleton_class
+    SINGLETON_CLASS: UnboundMethod
+
+    # Kernel#respond_to?
+    RESPOND_TOP: UnboundMethod
+
+    class ArgumentsReturn
+      type exit_type = :return | :exception | :break
+
+      attr_reader arguments: Array[untyped]
+
+      attr_reader exit_value: untyped
+
+      attr_reader exit_type: exit_type
+
+      def initialize: (arguments: Array[untyped], exit_value: untyped, exit_type: exit_type) -> void
+
+      def self.return: (arguments: Array[untyped], value: untyped) -> ArgumentsReturn
+
+      def self.exception: (arguments: Array[untyped], exception: untyped) -> ArgumentsReturn
+
+      def self.break: (arguments: Array[untyped]) -> ArgumentsReturn
+
+      def return_value: () -> untyped
+
+      def exception: () -> untyped
+
+      def return?: () -> bool
+
+      def exception?: () -> bool
+
+      def break?: () -> bool
+    end
+
+    class CallTrace
+      attr_reader method_name: Symbol
+
+      attr_reader method_call: ArgumentsReturn
+
+      attr_reader block_calls: Array[ArgumentsReturn]
+
+      attr_reader block_given: bool
+
+      def initialize: (method_name: Symbol, method_call: ArgumentsReturn, block_calls: Array[ArgumentsReturn], block_given: bool) -> void
+    end
+
+    attr_accessor self.suffix: String
+
+    def self.reset_suffix: () -> String
+
+    def self.call: (untyped receiver, UnboundMethod, *untyped) ?{ () -> void } -> void
+  end
+end

data/sig/type_alias_dependency.rbs

@@ -0,0 +1,53 @@
+module RBS
+  # TypeAliasDependency calculates the dependencies between type aliases
+  #
+  # The dependencies are normalized automatically.
+  #
+  class TypeAliasDependency
+    attr_reader env: Environment
+
+    # A hash table from type alias name to it's direct dependencies
+    #
+    # The source type name and dependencies are normalized.
+    #
+    attr_reader direct_dependencies: Hash[TypeName, Set[TypeName]]
+
+    # A hash table from type alias name to a hash name with keys of transitive dependencies
+    #
+    # The source type name and dependencies are normalized.
+    #
+    attr_reader dependencies: Hash[TypeName, Hash[TypeName, bool]]
+
+    def initialize: (env: Environment) -> void
+
+    # Returns `true` if given type alias is circular
+    #
+    # Normalized given type name automatically.
+    #
+    def circular_definition?: (TypeName alias_name) -> bool
+
+    # Returns the set of direct dependencies from the given type name
+    #
+    # Given type name will be normalized automatically.
+    # Returns normalized type names.
+    #
+    def direct_dependencies_of: (TypeName) -> Set[TypeName]
+
+    # Returns the set of dependencies from the given type name
+    #
+    # Given type name will be normalized automatically.
+    # Returns normalized type names.
+    #
+    def dependencies_of: (TypeName) -> Set[TypeName]
+
+    def build_dependencies: () -> void
+
+    def transitive_closure: () -> void
+
+    private
+
+    def direct_dependency: (Types::t `type`, ?Set[TypeName] result) -> Set[TypeName]
+
+    def dependency: (TypeName start, TypeName vertex, ?boolish nested) -> void
+  end
+end

data/sig/type_alias_regularity.rbs

@@ -0,0 +1,98 @@
+module RBS
+  # `TypeAliasRegularity` validates if a type alias is regular or not.
+  #
+  # Generic and recursive type alias cannot be polymorphic in their definitions.
+  #
+  # ```rbs
+  # type foo[T] = Integer
+  #             | foo[T]?     # Allowed. The type argument of `foo` doesn't change.
+  #
+  # type bar[T] = Integer
+  #             | foo[T]
+  #             | foo[Array[T]]  # Allowed. There are two type arguments `T` and `Array[T]` of `foo`, but it's not definition of `foo`.
+  #
+  # type baz[T] = Integer
+  #             | baz[Array[T]]  # Error. Recursive definition of `baz` has different type argument from the definition.
+  # ```
+  #
+  # The `#nonregular?` method can be used to test if given type name is regular or not.
+  #
+  # ```rb
+  # validator = RBS::TypeAliasRegularity.validate(env: env)
+  #
+  # validator.nonregular?(TypeName.parse("::foo"))    # => nil
+  # validator.nonregular?(TypeName.parse("::bar"))    # => nil
+  # validator.nonregular?(TypeName.parse("::baz"))    # => TypeAliasRegularity::Diagnostic
+  # ```
+  #
+  # A special case is when the type argument is `untyped`.
+  #
+  # ```rbs
+  # type foo[T] = Integer | foo[untyped]    # This is allowed.
+  # ```
+  #
+  class TypeAliasRegularity
+    attr_reader env: Environment
+
+    attr_reader builder: DefinitionBuilder
+
+    # Diagnostics of each type aliases.
+    # The type names are normalized.
+    #
+    attr_reader diagnostics: Hash[TypeName, Diagnostic]
+
+    # `Diagnostic` represents an non-regular type alias declaration error.
+    # It consists of the name of the alias type and a type on which the nonregularity is detected.
+    #
+    # ```rbs
+    # type t[T] = Integer | t[T?]
+    # ```
+    #
+    # The type `t` is nonregular because it contains `t[T?]` on it's right hand side.
+    #
+    # ```
+    # diagnostic = validator.nonregular?(TypeName.parse("::t"))
+    # diagnostic.type_name         # => TypeName.parse("::t")
+    # diagnostic.nonregular_type   # => t[T?]
+    # ```
+    #
+    class Diagnostic
+      attr_reader type_name: TypeName
+
+      attr_reader nonregular_type: Types::Alias
+
+      def initialize: (type_name: TypeName, nonregular_type: Types::Alias) -> void
+    end
+
+    # Returns new instance which already run `#validate`.
+    #
+    def self.validate: (env: Environment) -> TypeAliasRegularity
+
+    def initialize: (env: Environment) -> void
+
+    # Returns `Diagnostic` instance if the alias type is nonregular.
+    # Returns `nil` if the alias type is regular.
+    #
+    # Normalizes the given type name automatically.
+    #
+    def nonregular?: (TypeName) -> Diagnostic?
+
+    def validate: () -> void
+
+    private
+
+    def validate_alias_type: (Types::Alias, Set[TypeName], Hash[TypeName, Types::Alias]) -> void
+
+    # Returns alias type for given type name, if the alias is generic.
+    # Returns nil if the type alias is not generic.
+    #
+    def build_alias_type: (TypeName) -> Types::Alias?
+
+    def compatible_args?: (Array[Types::t], Array[Types::t]) -> boolish
+
+    def each_alias_type: (Types::t) { (Types::Alias) -> void } -> void
+
+    # Yields set of normalized type names
+    def each_mutual_alias_defs: () { (Set[TypeName]) -> void } -> void
+  end
+end

data/sig/type_param.rbs

@@ -0,0 +1,110 @@
+module RBS
+  module AST
+    class TypeParam
+      # Key
+      # ^^^ name
+      #
+      # unchecked out Elem < _ToJson = untyped
+      # ^^^^^^^^^                                 unchecked
+      #           ^^^                             variance
+      #               ^^^^                        name
+      #                    ^^^^^^^^^              upper_bound
+      #                              ^^^^^^^^^    default
+      type loc = Location[:name, :variance | :unchecked | :upper_bound | :default]
+
+      type variance = :invariant | :covariant | :contravariant
+
+      type bound = Types::ClassInstance | Types::ClassSingleton | Types::Interface
+
+      attr_reader name: Symbol
+      attr_reader variance: variance
+      attr_reader location: loc?
+
+      %a{pure} def upper_bound: () -> bound?
+
+      attr_reader upper_bound_type: Types::t?
+
+      attr_reader default_type: Types::t?
+
+      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, location: loc?, ?default_type: Types::t?, ?unchecked: bool) -> void
+
+      include _ToJson
+
+      def ==: (untyped) -> bool
+
+      def eql?: (untyped) -> bool
+
+      def hash: () -> Integer
+
+      @unchecked: bool
+
+      def unchecked!: (?boolish) -> self
+
+      def unchecked?: () -> bool
+
+      def map_type: () { (Types::t) -> Types::t } -> TypeParam
+
+      # Helper function to resolve _class instance types_ to _type variables_.
+      #
+      # We need this step because RBS language has an identical syntax for both unqualified class instance types and type variables.
+      # `String` may be an instance of `::String` class or type variable depending on the list of bound type variables.
+      #
+      # So, we need second pass to parse the following generics parameter declaration.
+      #
+      # ```rbs
+      # class Foo[X < _Each[Y], Y]
+      #                   # ^ We want this `Y` to be a type variable.
+      # end
+      # ```
+      #
+      def self.resolve_variables: (Array[TypeParam]) -> void
+
+      def self.subst_var: (Set[Symbol], Types::t) -> Types::t
+
+      # Rename type parameter name.
+      #
+      # The renaming cannot be done separately because a set of `TypeParam` decls may be mutual recursive.
+      #
+      # Example:
+      #
+      # * Renaming `A -> X, B -> Y`
+      # * Input `[A, B < _Pushable[A]]`
+      # * Result `[X, Y < _Pushable[X]]`
+      #
+      def self.rename: (Array[TypeParam], new_names: Array[Symbol]) -> Array[TypeParam]
+
+      def to_s: () -> String
+
+      # Validates TypeParams if it refers another optional type params
+      #
+      # * Returns array of TypeParam objects that refers other optional type params
+      # * Returns `nil` if all type params are valid
+      #
+      def self.validate: (Array[TypeParam]) -> Array[TypeParam]?
+
+      # Returns an application with respect to type params' default
+      #
+      def self.application: (Array[TypeParam], Array[Types::t]) -> Substitution?
+
+      # Returns an array of type args, that fills omitted types with the defaults
+      #
+      # ```rbs
+      # interface _Foo[T, S = untyped]
+      # end
+      # ```
+      #
+      # Normalizing type args with `_Foo` works as following:
+      #
+      # ```rbs
+      # _Foo[String]                   # => _Foo[String, untyped]
+      # _Foo[String, Integer]          # => _Foo[String, Integer]
+      # _Foo                           # => _Foo                            (Omitting missing args)
+      # _Foo[String, Integer, untyped] # => _Foo[String, Integer, untyped]  (Keeping extra args)
+      # ```
+      #
+      # Note that it allows invalid arities, returning the `args` immediately.
+      #
+      def self.normalize_args: (Array[TypeParam], Array[Types::t]) -> Array[Types::t]
+    end
+  end
+end