steep 1.6.0 → 1.7.1

data/sig/steep/interface/function.rbs

@@ -1,265 +0,0 @@
-module Steep
-  module Interface
-    class Function
-      class Params
-        module Utils
-          def union: (*AST::Types::t types, ?null: bool) -> AST::Types::t
-
-          def intersection: (*AST::Types::t types) -> AST::Types::t
-        end
-
-        type t = PositionalParams::param | KeywordParams
-
-        class PositionalParams
-          class Base
-            attr_reader type: AST::Types::t
-
-            def initialize: (AST::Types::t `type`) -> void
-
-            def ==: (untyped other) -> bool
-
-            alias eql? ==
-
-            def hash: () -> Integer
-
-            def subst: (Substitution s) -> self
-
-            def var_type: () -> AST::Types::t
-
-            def map_type: () { (AST::Types::t) -> AST::Types::t } -> self
-          end
-
-          class Required < Base
-          end
-
-          class Optional < Base
-          end
-
-          class Rest < Base
-          end
-
-          type param = Required | Optional | Rest
-
-          attr_reader head: param
-
-          attr_reader tail: PositionalParams?
-
-          def initialize: (head: param, tail: PositionalParams?) -> void
-
-          def self.required: (AST::Types::t `type`, ?PositionalParams? tail) -> PositionalParams
-
-          def self.optional: (AST::Types::t `type`, ?PositionalParams? tail) -> PositionalParams
-
-          def self.rest: (AST::Types::t `type`, ?PositionalParams? tail) -> PositionalParams
-
-          def to_ary: () -> [param, PositionalParams?]
-
-          def map: () { (param) -> param } -> PositionalParams
-
-          def map_type: () { (AST::Types::t) -> AST::Types::t } -> PositionalParams
-
-          def subst: (Substitution s) -> PositionalParams
-
-          def ==: (untyped other) -> bool
-
-          alias eql? ==
-
-          def hash: () -> Integer
-
-          def each: () { (param) -> void } -> void
-                  | () -> Enumerator[param, void]
-
-          def each_type: () { (AST::Types::t) -> void } -> void
-                       | () -> Enumerator[AST::Types::t, void]
-
-          def size: () -> Integer
-
-          def self.build: (required: Array[AST::Types::t], optional: Array[AST::Types::t], rest: AST::Types::t?) -> PositionalParams
-
-          extend Utils
-
-          # Calculates xs + ys.
-          # Never fails.
-          def self.merge_for_overload: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams
-
-          # xs | ys
-          def self.merge_for_union: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams?
-
-          # Calculates xs & ys.
-          # Raises when failed.
-          #
-          def self.merge_for_intersection: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams?
-        end
-
-        class KeywordParams
-          attr_reader requireds: Hash[Symbol, AST::Types::t]
-
-          attr_reader optionals: Hash[Symbol, AST::Types::t]
-
-          attr_reader rest: AST::Types::t?
-
-          def initialize: (?requireds: ::Hash[untyped, untyped], ?optionals: ::Hash[untyped, untyped], ?rest: untyped?) -> void
-
-          def ==: (untyped other) -> untyped
-
-          alias eql? ==
-
-          def hash: () -> untyped
-
-          def update: (?requireds: untyped, ?optionals: untyped, ?rest: untyped) -> untyped
-
-          def empty?: () -> bool
-
-          def each: () { ([Symbol?, AST::Types::t]) -> void } -> void
-                  | () -> Enumerator[[Symbol?, AST::Types::t], void]
-
-          def each_type: () { (AST::Types::t) -> void } -> void
-                       | () -> Enumerator[AST::Types::t, void]
-
-          def map_type: () { (AST::Types::t) -> AST::Types::t } -> KeywordParams
-
-          def subst: (Substitution s) -> KeywordParams
-
-          def size: () -> Integer
-
-          def keywords: () -> Set[Symbol]
-
-          include Utils
-
-          # For overloading
-          def +: (untyped other) -> untyped
-
-          # For union
-          def |: (untyped other) -> untyped
-
-          # For intersection
-          def &: (untyped other) -> (nil | untyped)
-        end
-
-        def required: () -> Array[AST::Types::t]
-
-        def optional: () -> Array[AST::Types::t]
-
-        %a{pure} def rest: () -> AST::Types::t?
-
-        attr_reader positional_params: PositionalParams?
-
-        attr_reader keyword_params: KeywordParams
-
-        def self.build: (?required: untyped, ?optional: untyped, ?rest: untyped?, ?required_keywords: ::Hash[untyped, untyped], ?optional_keywords: ::Hash[untyped, untyped], ?rest_keywords: untyped?) -> untyped
-
-        def initialize: (positional_params: untyped, keyword_params: untyped) -> void
-
-        def update: (?positional_params: untyped, ?keyword_params: untyped) -> untyped
-
-        def first_param: () -> untyped
-
-        def with_first_param: (untyped param) -> untyped
-
-        def has_positional?: () -> (true | false)
-
-        def self.empty: () -> untyped
-
-        def ==: (untyped other) -> untyped
-
-        alias eql? ==
-
-        def hash: () -> untyped
-
-        def flat_unnamed_params: () -> Array[[:required | :optional, AST::Types::t]]
-
-        def flat_keywords: () -> untyped
-
-        def required_keywords: () -> untyped
-
-        def optional_keywords: () -> untyped
-
-        def rest_keywords: () -> untyped
-
-        def has_keywords?: () -> untyped
-
-        def each_positional_param: () { (PositionalParams::Base) -> void } -> void
-
-        def without_keywords: () -> untyped
-
-        def drop_first: () -> untyped
-
-        def each_type: () { (AST::Types::t) -> void } -> void
-                     | () -> Enumerator[AST::Types::t, void]
-
-        def free_variables: () -> untyped
-
-        def closed?: () -> untyped
-
-        def subst: (Substitution s) -> Params
-
-        def size: () -> untyped
-
-        def to_s: () -> ::String
-
-        def map_type: () { (AST::Types::t) -> AST::Types::t } -> Params
-
-        def empty?: () -> bool
-
-        # Returns true if all arguments are non-required.
-        def optional?: () -> bool
-
-        # self + params returns a new params for overloading.
-        #
-        def +: (Params other) -> Params
-
-        # Returns the intersection between self and other.
-        # Returns nil if the intersection cannot be computed.
-        #
-        #   (self & other) <: self
-        #   (self & other) <: other
-        #
-        # `self & other` accept `arg` if `arg` is acceptable for both of `self` and `other`.
-        #
-        def &: (Params other) -> Params?
-
-        # Returns the union between self and other.
-        #
-        #    self <: (self | other)
-        #   other <: (self | other)
-        #
-        # `self | other` accept `arg` if `self` accepts `arg` or `other` accepts `arg`.
-        #
-        def |: (Params other) -> Params?
-      end
-
-      type location = RBS::Location[untyped, untyped]
-
-      attr_reader params: Params
-
-      attr_reader return_type: AST::Types::t
-
-      attr_reader location: location?
-
-      def initialize: (params: Params, return_type: AST::Types::t, location: location?) -> void
-
-      def ==: (untyped other) -> bool
-
-      alias eql? ==
-
-      def hash: () -> Integer
-
-      def free_variables: () -> Set[Symbol]
-
-      def subst: (Substitution s) -> Function
-
-      alias each_child each_type
-
-      def each_type: () { (AST::Types::t) -> void } -> void
-                   | () -> Enumerator[AST::Types::t, void]
-
-      def map_type: () { (AST::Types::t) -> AST::Types::t } -> Function
-
-      def with: (?params: Params, ?return_type: AST::Types::t) -> Function
-
-      def to_s: () -> ::String
-
-      def closed?: () -> bool
-    end
-  end
-end

data/sig/steep/interface/method_type.rbs

@@ -1,105 +0,0 @@
-use Steep::TypeInference::MethodCall::MethodDecl
-
-module Steep
-  module Interface
-    class MethodType
-      attr_reader type_params: Array[TypeParam]
-
-      attr_reader type: Function
-
-      attr_reader block: Block?
-
-      attr_reader method_decls: Set[MethodDecl]
-
-      @fvs: Set[Symbol]
-
-      def initialize: (type_params: Array[TypeParam], type: Function, block: Block?, method_decls: Set[MethodDecl]) -> void
-
-      def ==: (untyped other) -> bool
-
-      alias eql? ==
-
-      def hash: () -> Integer
-
-      def free_variables: () -> Set[Symbol]
-
-      def subst: (Substitution s) -> MethodType
-
-      def each_type: () { (AST::Types::t) -> void } -> void
-                   | () -> Enumerator[AST::Types::t, void]
-
-      def instantiate: (Substitution s) -> MethodType
-
-      def with: (?type_params: Array[TypeParam], ?type: Function, ?block: Block?, ?method_decls: Set[MethodDecl]) -> MethodType
-
-      def to_s: () -> ::String
-
-      def map_type: () { (AST::Types::t) -> AST::Types::t } -> MethodType
-
-      # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
-      #
-      def unify_overload: (MethodType other) -> MethodType
-
-      alias + unify_overload
-
-      def equals_modulo_type_params?: (MethodType other) -> bool
-
-      # Returns a method type which is a super-type of both `type1` and `type2`.
-      #   `type1` <: union(`type1`, `type2`) && `type2` <: union(`type1`, `type2`)
-      #
-      # Returns `nil` if `type1` and `type2` are incompatible.
-      #
-      # This tries to generate the best result for polymorphic methods, but the support is limited.
-      # It works when:
-      #
-      # * `type1` and `type2` are equal modulo type parameters (`[A] () -> A` | `[B] () -> B` → `[A] () -> A`), or
-      # * The type parameter occurences are identical (`[A] (::Integer) -> A` | `[B] (::String) -> B` → `[A] (::Integer & ::String) -> A`)
-      #
-      # Otherwise it fails (returns `nil`).
-      #
-      def self.union: (MethodType type1, MethodType type2, Subtyping::Check) -> MethodType?
-
-      # Returns a method type which is a sub-type of both `type1` and `type2`.
-      #
-      # ```
-      # intersection(type1, type2) <: type1 && intersection(type1, type2) <: type2
-      # ```
-      #
-      # Returns `nil` if `type1` and `type2` are incompatible.
-      #
-      # This tries to generate the best result for polymorphic methods, but the support is limited.
-      # It works when:
-      #
-      # * `type1` and `type2` are equal modulo type parameters (`[A] () -> A` & `[B] () -> B` → `[A] () -> A`), or
-      # * The type parameter occurences are identical (`[A] (::Integer) -> A` & `[B] (::String) -> B` → `[A] (::Integer | ::String) -> A`)
-      #
-      # Otherwise it fails (returns `nil`).
-      #
-      def self.intersection: (MethodType type1, MethodType type2, Subtyping::Check) -> MethodType?
-
-      def self.try_type_params: (
-        MethodType type1,
-        MethodType type2,
-        Subtyping::Check,
-        ^(MethodType, MethodType) -> MethodType?,
-        ^(MethodType original, MethodType generated) -> Subtyping::Relation[MethodType]
-      )  -> MethodType?
-
-      # Returns a method type which is a super-type of both self and other.
-      #   self <: (self | other) && other <: (self | other)
-      #
-      # * Returns `nil` if self and other are incompatible.
-      # * Ignores all type parameters.
-      #
-      def |: (MethodType other) -> MethodType?
-
-      # Returns a method type which is a sub-type of both self and other.
-      #   (self & other) <: self && (self & other) <: other
-      #
-      # * Returns `nil` if self and other are incompatible.
-      # * Ignores all type parameters.
-      #
-      def &: (MethodType other) -> MethodType?
-    end
-  end
-end

data/sig/steep/interface/shape.rbs

@@ -1,61 +0,0 @@
-module Steep
-  module Interface
-    class Shape
-      class Entry
-        attr_reader method_types: Array[MethodType]
-
-        def initialize: (method_types: Array[MethodType]) -> void
-
-        def to_s: () -> String
-      end
-
-      class Methods
-        def []=: (Symbol, Entry) -> Entry
-
-        def []: (Symbol) -> Entry?
-
-        def key?: (Symbol) -> bool
-
-        def each: () { ([Symbol, Entry]) -> void } -> void
-                | () -> Enumerator[[Symbol, Entry], void]
-
-        def each_name: () { (Symbol) -> void } -> void
-                     | () -> Enumerator[Symbol, void]
-
-        include Enumerable[[Symbol, Entry]]
-
-        attr_reader substs: Array[Substitution]
-
-        attr_reader methods: Hash[Symbol, Entry]
-        attr_reader resolved_methods: Hash[Symbol, Entry?]
-
-        def initialize: (substs: Array[Substitution], methods: Hash[Symbol, Entry]) -> void
-
-        @subst: Substitution?
-        def subst: () -> Substitution
-
-        def push_substitution: (Substitution) -> Methods
-
-        def merge!: (Methods other) -> void
-
-        # def +: (Methods other) -> Methods
-      end
-
-      attr_reader type: AST::Types::t
-
-      attr_reader methods: Methods
-
-      @private: bool
-
-      def initialize: (type: AST::Types::t, private: bool, ?methods: Methods?) -> void
-
-      def update: (?type: AST::Types::t, ?methods: Methods) -> self
-
-      def private?: () -> bool
-
-      def public?: () -> bool
-
-      def subst: (Substitution, ?type: AST::Types::t?) -> Shape
-    end
-  end
-end

data/sig/steep/interface/substitution.rbs

@@ -1,49 +0,0 @@
-module Steep
-  module Interface
-    class Substitution
-      class InvalidSubstitutionError < StandardError
-        attr_reader vars_size: Integer
-
-        attr_reader types_size: Integer
-
-        def initialize: (vars_size: Integer, types_size: Integer) -> void
-      end
-
-      attr_reader dictionary: Hash[Symbol, AST::Types::t]
-
-      attr_reader instance_type: AST::Types::t?
-
-      attr_reader module_type: AST::Types::t?
-
-      attr_reader self_type: AST::Types::t?
-
-      def initialize: (dictionary: Hash[Symbol, AST::Types::t], instance_type: AST::Types::t?, module_type: AST::Types::t?, self_type: AST::Types::t?) -> void
-
-      def self.empty: () -> instance
-
-      def empty?: () -> bool
-
-      def domain: () -> Set[AST::Types::variable]
-
-      def to_s: () -> ::String
-
-      def []: (Symbol key) -> AST::Types::t
-
-      def key?: (Symbol var) -> bool
-
-      def self.build: (Array[Symbol] vars, ?Array[AST::Types::t]? types, ?instance_type: AST::Types::t?, ?module_type: AST::Types::t?, ?self_type: AST::Types::t?) -> Substitution
-
-      def except: (Array[Symbol] vars) -> Substitution
-
-      def except!: (Array[Symbol] vars) -> self
-
-      def merge!: (Substitution s, ?overwrite: bool) -> self
-
-      def merge: (Substitution s) -> Substitution
-
-      def apply?: (AST::Types::t) -> bool
-
-      def add!: (Symbol v, AST::Types::t ty) -> self
-    end
-  end
-end

data/sig/steep/interface/type_param.rbs

@@ -1,43 +0,0 @@
-module Steep
-  module Interface
-    class TypeParam
-      type loc = RBS::Location[untyped, untyped]
-
-      type variance = RBS::AST::TypeParam::variance
-
-      attr_reader name: Symbol
-
-      attr_reader upper_bound: AST::Types::t?
-
-      attr_reader variance: variance
-
-      attr_reader unchecked: bool
-
-      attr_reader location: loc?
-
-      def initialize: (name: Symbol, upper_bound: AST::Types::t?, variance: variance, unchecked: bool, ?location: loc?) -> void
-
-      def ==: (untyped other) -> bool
-
-      alias eql? ==
-
-      def hash: () -> Integer
-
-      # Rename the type parameters to fresh names
-      #
-      # Returns a pair of renamed type parameters and substitution.
-      #
-      # ```rb
-      # TypeParam.rename([`X`, `Y`], [:X, :Y])  # [[`X(0)`, `Y(1)`], `{ X => X(0), Y => Y(1) }`]
-      # ```
-      #
-      def self.rename: (Array[TypeParam] params, ?Array[Symbol] conflicting_names, ?Array[Symbol] new_names) -> [Array[TypeParam], Substitution]
-
-      def to_s: () -> String
-
-      def update: (?name: Symbol, ?upper_bound: AST::Types::t?, ?variance: variance, ?unchecked: bool, ?location: loc?) -> TypeParam
-
-      def subst: (Substitution s) -> TypeParam
-    end
-  end
-end

data/sig/steep/method_name.rbs

@@ -1,30 +0,0 @@
-module Steep
-  type method_name = InstanceMethodName | SingletonMethodName
-
-  class InstanceMethodName
-    attr_reader type_name: RBS::TypeName
-    attr_reader method_name: Symbol
-
-    def initialize: (type_name: RBS::TypeName, method_name: Symbol) -> void
-
-    def relative: () -> InstanceMethodName
-  end
-
-  class SingletonMethodName
-    attr_reader type_name: RBS::TypeName
-    attr_reader method_name: Symbol
-
-    def initialize: (type_name: RBS::TypeName, method_name: Symbol) -> void
-
-    def relative: () -> SingletonMethodName
-  end
-
-  class ::Object
-    # Returns method name corresponding to given `string`.
-    #
-    # * `ClassName#method_name` syntax returns an `InstanceMethodName` object
-    # * `ClassName.method_name` syntax returns a `SingletonMethodName` object
-    #
-    def MethodName: (String string) -> (InstanceMethodName | SingletonMethodName)
-  end
-end

data/sig/steep/module_helper.rbs

@@ -1,16 +0,0 @@
-module Steep
-  module ModuleHelper
-    # Translate a *const* node to a type name if possible
-    #
-    # ```ruby
-    # Foo::Bar     # => `Foo::Bar`
-    # foo::Bar     # => nil
-    # ```
-    #
-    def module_name_from_node: (Parser::AST::Node? parent_node, Symbol constant_name) -> RBS::TypeName?
-
-    # Translate a *const* node to a namespace if possible
-    # 
-    def namespace_from_node: (Parser::AST::Node? node) -> RBS::Namespace?
-  end
-end

data/sig/steep/node_helper.rbs

@@ -1,78 +0,0 @@
-use Parser::AST::Node
-use Parser::AST::_Condition, Parser::AST::_Ternary, Parser::AST::_Keyword, Parser::AST::_RescueBody, Parser::AST::_Send
-use Parser::Source::Map
-
-module Steep
-  module NodeHelper
-    def each_child_node: (Parser::AST::Node) -> Enumerator[Parser::AST::Node, void]
-                       | (Parser::AST::Node) { (Parser::AST::Node) -> void } -> void
-
-    def each_descendant_node: (Parser::AST::Node) -> Enumerator[Parser::AST::Node, void]
-                            | (Parser::AST::Node) { (Parser::AST::Node) -> void } -> void
-
-    # Returns true if given node is a syntactic-value node
-    #
-    def value_node?: (Parser::AST::Node) -> bool
-
-    type condition_loc = Map & _Condition
-
-    type ternary_loc = Map & _Ternary
-
-    def deconstruct_if_node: (Node) -> [Node, Node?, Node?, condition_loc | ternary_loc]?
-
-    def deconstruct_if_node!: (Node) -> [Node, Node?, Node?, condition_loc | ternary_loc]
-
-    def test_if_node: (Node) { (Node, Node?, Node?, condition_loc | ternary_loc) -> bool } -> bool
-
-    type keyword_loc = Map & Parser::AST::_Keyword
-
-    def deconstruct_whileish_node: (Node) -> [Node, Node?, keyword_loc]?
-
-    def deconstruct_whileish_node!: (Node) -> [Node, Node?, keyword_loc]
-
-    def test_whileish_node: (Node) { (Node, Node?, keyword_loc) -> bool } -> bool
-
-    def deconstruct_case_node: (Node) -> [Node?, Array[Node], Node?, condition_loc]?
-
-    def deconstruct_case_node!: (Node) -> [Node?, Array[Node], Node?, condition_loc]
-
-    def test_case_node: (Node) { (Node?, Array[Node], Node?, condition_loc) -> bool } -> bool
-
-    def deconstruct_when_node: (Node) -> [Array[Node], Node?, keyword_loc]?
-
-    def deconstruct_when_node!: (Node) -> [Array[Node], Node?, keyword_loc]
-
-    def test_when_node: (Node) { (Array[Node], Node?, keyword_loc) -> bool } -> bool
-
-    def deconstruct_rescue_node: (Node) -> [Node?, Array[Node], Node?, condition_loc]?
-
-    def deconstruct_rescue_node!: (Node) -> [Node?, Array[Node], Node?, condition_loc]
-
-    def test_rescue_node: (Node) { (Node?, Array[Node], Node?, condition_loc) -> bool } -> bool
-
-    type rescue_body_loc = Map & _RescueBody
-
-    def deconstruct_resbody_node: (Node) -> [Node?, Node?, Node?, rescue_body_loc]?
-
-    def deconstruct_resbody_node!: (Node) -> [Node?, Node?, Node?, rescue_body_loc]
-
-    def test_resbody_node: (Node) { (Node?, Node?, Node?, rescue_body_loc) -> bool } -> bool
-
-    type send_loc = Map & _Send
-
-    def deconstruct_send_node: (Node) -> [Node?, Symbol, Array[Node], send_loc]?
-
-    def deconstruct_send_node!: (Node) -> [Node?, Symbol, Array[Node], send_loc]
-
-    def test_send_node: (Node) { (Node?, Symbol, Array[Node], send_loc) -> bool } -> bool
-
-    # Deconstruct sendish node and it's associated block node
-    #
-    # Receives a sequence of node tree where the leaf node comes first.
-    # If the first node is `send`, `csend`, `super`, or `zsuper`, it is the sendish node.
-    #
-    # If the next node is a `block` or `numblock` that is associated to the *sendish node*, it is the block node.
-    #
-    def deconstruct_sendish_and_block_nodes: (*Parser::AST::Node) -> [Parser::AST::Node, Parser::AST::Node?]?
-  end
-end

data/sig/steep/path_helper.rbs

@@ -1,15 +0,0 @@
-module Steep
-  module PathHelper
-    # Receives a String that represents a *file* URI and returns a Pathname
-    #
-    # Returns `nil` when the schema of given URI is not `file://`.
-    #
-    def self?.to_pathname: (String uri, ?dosish: bool) -> Pathname?
-
-    def self?.to_pathname!: (String uri, ?dosish: bool) -> Pathname
-
-    # Receives a Pathname and returns a *file* URI
-    #
-    def self?.to_uri: (Pathname | String path, ?dosish: bool) -> URI::File
-  end
-end