steep 1.7.0.dev.4 → 1.7.0

data/sig/steep/type_inference/method_call.rbs

@@ -1,124 +0,0 @@
-module Steep
-  module TypeInference
-    module MethodCall
-      class MethodDecl
-        attr_reader method_name: method_name
-
-        attr_reader method_def: RBS::Definition::Method::TypeDef
-
-        def initialize: (method_name: method_name, method_def: RBS::Definition::Method::TypeDef) -> void
-
-        def hash: () -> Integer
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def method_type: () -> RBS::MethodType
-      end
-
-      class MethodContext
-        attr_reader method_name: method_name
-
-        def initialize: (method_name: method_name) -> void
-
-        def to_s: () -> String
-      end
-
-      class ModuleContext
-        attr_reader type_name: RBS::TypeName
-
-        def initialize: (type_name: RBS::TypeName) -> void
-
-        def to_s: () -> String
-      end
-
-      class TopLevelContext
-        def to_s: () -> String
-      end
-
-      class UnknownContext
-        def to_s: () -> String
-      end
-
-      type context = MethodContext | ModuleContext | TopLevelContext | UnknownContext
-
-      class Base
-        attr_reader node: Parser::AST::Node
-
-        attr_reader context: context
-
-        attr_reader method_name: Symbol
-
-        attr_reader return_type: AST::Types::t
-
-        attr_reader receiver_type: AST::Types::t
-
-        def initialize: (node: Parser::AST::Node, context: context, method_name: Symbol, receiver_type: AST::Types::t, return_type: AST::Types::t) -> void
-
-        def with_return_type: (AST::Types::t new_type) -> self
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def hash: () -> Integer
-      end
-
-      type t = Typed | Special | Untyped | NoMethodError | Error
-
-      class Typed < Base
-        attr_reader actual_method_type: Interface::MethodType
-
-        attr_reader method_decls: Set[MethodDecl]
-
-        def initialize: (node: Parser::AST::Node, context: context, method_name: Symbol, receiver_type: AST::Types::t, actual_method_type: Interface::MethodType, method_decls: Set[MethodDecl], return_type: AST::Types::t) -> void
-
-        def update: (?node: Parser::AST::Node, ?return_type: AST::Types::t) -> self
-
-        def pure?: () -> bool
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def hash: () -> Integer
-      end
-
-      class Special < Typed
-      end
-
-      class Untyped < Base
-        def initialize: (node: Parser::AST::Node, context: context, method_name: Symbol) -> void
-      end
-
-      class NoMethodError < Base
-        attr_reader error: Diagnostic::Ruby::NoMethod
-
-        def initialize: (
-          node: Parser::AST::Node,
-          context: context,
-          method_name: Symbol,
-          receiver_type: AST::Types::t,
-          error: Diagnostic::Ruby::NoMethod
-        ) -> void
-      end
-
-      class Error < Base
-        attr_reader errors: Array[Diagnostic::Ruby::Base]
-
-        attr_reader method_decls: Set[MethodDecl]
-
-        def initialize: (
-          node: Parser::AST::Node,
-          context: context,
-          method_name: Symbol,
-          receiver_type: AST::Types::t,
-          errors: Array[Diagnostic::Ruby::Base],
-          ?method_decls: Set[MethodDecl],
-          ?return_type: AST::Types::t
-        ) -> void
-      end
-    end
-  end
-end

data/sig/steep/type_inference/method_params.rbs

@@ -1,127 +0,0 @@
-use Parser::AST::Node, Steep::Interface::MethodType
-use Steep::Interface::Function::Params, Steep::Interface::Block
-
-module Steep
-  module TypeInference
-    # A MethodParams object provides the information of parameters from MethodType and nodes
-    #
-    # It primarly provides a mapping from a local variable (method parameter) to its type.
-    #
-    class MethodParams
-      class BaseParameter
-        attr_reader name: Symbol
-
-        attr_reader type: AST::Types::t?
-
-        attr_reader node: Node
-
-        def initialize: (name: Symbol, type: AST::Types::t?, node: Node) -> void
-
-        def optional?: () -> bool
-
-        def value: () -> Node?
-
-        def var_type: () -> AST::Types::t
-
-        def untyped?: () -> bool
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def hash: () -> Integer
-      end
-
-      class PositionalParameter < BaseParameter
-      end
-
-      class KeywordParameter < BaseParameter
-      end
-
-      class BaseRestParameter
-        attr_reader name: Symbol
-
-        attr_reader type: AST::Types::t?
-
-        attr_reader node: Node
-
-        def initialize: (name: Symbol, type: AST::Types::t?, node: Node) -> void
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def hash: () -> Integer
-      end
-
-      class PositionalRestParameter < BaseRestParameter
-        def var_type: () -> AST::Types::Name::Instance
-      end
-
-      class KeywordRestParameter < BaseRestParameter
-        def var_type: () -> AST::Types::Name::Instance
-      end
-
-      class BlockParameter
-        attr_reader name: Symbol
-
-        attr_reader type: Interface::Function?
-
-        attr_reader node: Node
-
-        attr_reader self_type: AST::Types::t?
-
-        def initialize: (name: Symbol, type: Interface::Function?, node: Node, optional: boolish, self_type: AST::Types::t?) -> void
-
-        @optional: boolish
-
-        def optional?: () -> bool
-
-        def var_type: () -> AST::Types::t
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def hash: () -> Integer
-      end
-
-      type param = PositionalParameter | KeywordParameter | PositionalRestParameter | KeywordRestParameter | BlockParameter
-
-      # The children of `:args` node
-      attr_reader args: Array[Node]
-
-      attr_reader method_type: MethodType?
-
-      # Mapping from the name of parameter to parameter object
-      attr_reader params: Hash[Symbol, param]
-
-      attr_reader errors: Array[Diagnostic::Ruby::Base]
-
-      # The type of `...`
-      #
-      # `nil` if the node doesn't have it.
-      #
-      attr_reader forward_arg_type: [Params, Block?] | true | nil
-
-      def initialize: (args: Array[Node], method_type: MethodType?, forward_arg_type: [Params, Block?] | true | nil) -> void
-
-      def []: (Symbol name) -> param
-
-      def param?: (Symbol) -> bool
-
-      def size: () -> Integer
-
-      def each_param: () { (param) -> void } -> void
-                    | () -> Enumerator[param, void]
-
-      def each: () { (Symbol, AST::Types::t) -> void } -> void
-
-      def update: (?forward_arg_type: [Params, Block?] | true | nil) -> MethodParams
-
-      def self.empty: (node: Node) -> MethodParams
-
-      def self.build: (node: Node, method_type: MethodType) -> MethodParams
-    end
-  end
-end

data/sig/steep/type_inference/multiple_assignment.rbs

@@ -1,76 +0,0 @@
-module Steep
-  module TypeInference
-    # This class provides an abstraction for multiple assignments.
-    #
-    class MultipleAssignment
-      type node_type_pair = [Parser::AST::Node, AST::Types::t]
-
-      # Encapsulate assignments included in one `masgn` node
-      #
-      # ```ruby
-      #   a, *b, c = rhs
-      # # ^          Leading assignments
-      # #    ^^      Splat assignment
-      # #        ^   Trailing assignments
-      # ```
-      #
-      class Assignments
-        attr_reader rhs_type: AST::Types::t
-
-        attr_reader optional: bool
-
-        # Assignments before `*` assignment
-        attr_reader leading_assignments: Array[node_type_pair]
-
-        # Assignments after `*` assignment
-        #
-        # Empty if there is no splat assignment.
-        #
-        attr_reader trailing_assignments: Array[node_type_pair]
-
-        # Splat assignment if present
-        attr_reader splat_assignment: node_type_pair?
-
-        def initialize: (
-          rhs_type: AST::Types::t,
-          optional: bool,
-          leading_assignments: Array[node_type_pair],
-          trailing_assignments: Array[node_type_pair],
-          splat_assignment: node_type_pair?
-        ) -> void
-
-        def each: () { (node_type_pair) -> void } -> void
-                | () -> Enumerator[node_type_pair, void]
-      end
-
-      def initialize: () -> void
-
-      # Receives multiple assignment left hand side, right hand side type, and `optional` flag, and returns Assignments object
-      #
-      # This implements a case analysis on `rhs_type`:
-      #
-      # 1. If `rhs_type` is tuple, it returns an Assignments object with corresponding assignments
-      # 2. If `rhs_type` is an array, it returns an Assignments object with corresponding assignments
-      # 3. If `rhs_type` is `untyped`, it returns an Assignments with `untyped` type
-      # 4. It returns `nil` otherwise
-      #
-      def expand: (Parser::AST::Node mlhs, AST::Types::t rhs_type, bool optional) -> Assignments?
-
-      # Returns a type hint for multiple assignment right hand side
-      #
-      # It constructs a structure of tuple types, based on the assignment lhs, and variable types.
-      #
-      def hint_for_mlhs: (Parser::AST::Node mlhs, TypeEnv env) -> AST::Types::t?
-
-      private
-
-      def expand_tuple: (Array[Parser::AST::Node] assignments, AST::Types::t rhs_type, Array[AST::Types::t] types, bool optional) -> Assignments
-
-      def expand_array: (Array[Parser::AST::Node] assignments, AST::Types::Name::Instance rhs_type, bool optional) -> Assignments
-
-      def expand_any: (Array[Parser::AST::Node] assignments, AST::Types::t rhs_type, AST::Types::t element_type, bool optional) -> Assignments
-
-      def expand_else: (Array[Parser::AST::Node] assignments, AST::Types::t rhs_type, bool optional) -> Assignments
-    end
-  end
-end

data/sig/steep/type_inference/send_args.rbs

@@ -1,243 +0,0 @@
-module Steep
-  module TypeInference
-    class SendArgs
-      class PositionalArgs
-        class NodeParamPair
-          attr_reader node: Parser::AST::Node
-
-          attr_reader param: Interface::Function::Params::PositionalParams::param
-
-          def initialize: (node: Parser::AST::Node, param: Interface::Function::Params::PositionalParams::param) -> void
-
-          include Equatable
-
-          def to_ary: () -> [Parser::AST::Node, Interface::Function::Params::t]
-        end
-
-        class NodeTypePair
-          attr_reader node: Parser::AST::Node
-
-          attr_reader type: AST::Types::t
-
-          def initialize: (node: Parser::AST::Node, type: AST::Types::t) -> void
-
-          include Equatable
-
-          def node_type: () -> AST::Types::t
-        end
-
-        class SplatArg
-          attr_reader node: Parser::AST::Node
-
-          attr_accessor type: AST::Types::t?
-
-          def initialize: (node: Parser::AST::Node) -> void
-
-          include Equatable
-        end
-
-        class UnexpectedArg
-          attr_reader node: Parser::AST::Node
-
-          def initialize: (node: Parser::AST::Node) -> void
-
-          include Equatable
-        end
-
-        class MissingArg
-          attr_reader params: Interface::Function::Params::PositionalParams?
-
-          def initialize: (params: Interface::Function::Params::PositionalParams?) -> void
-
-          include Equatable
-        end
-
-        type arg = NodeParamPair | NodeTypePair | SplatArg | error_arg
-
-        type error_arg = UnexpectedArg | MissingArg
-
-        attr_reader args: Array[Parser::AST::Node]
-
-        attr_reader index: Integer
-
-        attr_reader positional_params: Interface::Function::Params::PositionalParams?
-
-        attr_reader uniform: bool
-
-        def initialize: (args: Array[Parser::AST::Node], index: Integer, positional_params: Interface::Function::Params::PositionalParams?, ?uniform: bool) -> void
-
-        %a{pure} def node: () -> Parser::AST::Node?
-
-        def following_args: () -> Array[Parser::AST::Node]
-
-        %a{pure} def param: () -> Interface::Function::Params::PositionalParams::param?
-
-        def update: (?index: Integer, ?positional_params: Interface::Function::Params::PositionalParams?, ?uniform: bool) -> PositionalArgs
-
-        def next: () -> [arg, PositionalArgs]?
-
-        def uniform_type: () -> AST::Types::t?
-
-        def consume: (Integer n, node: Parser::AST::Node) -> [
-          UnexpectedArg | Array[Interface::Function::Params::PositionalParams::param] | nil,
-          PositionalArgs
-        ]
-
-        def consume0: (
-          Integer n,
-          node: Parser::AST::Node,
-          params: Interface::Function::Params::PositionalParams?,
-          ps: Array[Interface::Function::Params::PositionalParams::param]
-        ) -> (Interface::Function::Params::PositionalParams | UnexpectedArg | nil)
-      end
-
-      class KeywordArgs
-        class ArgTypePairs
-          attr_reader pairs: Array[untyped]
-
-          def initialize: (pairs: Array[untyped]) -> void
-
-          include Equatable
-
-          def []: (Integer index) -> untyped
-
-          def size: () -> Integer
-        end
-
-        class SplatArg
-          attr_reader node: Parser::AST::Node
-
-          attr_accessor type: AST::Types::t?
-
-          def initialize: (node: Parser::AST::Node) -> void
-
-          include Equatable
-        end
-
-        class UnexpectedKeyword
-          attr_reader keyword: Symbol?
-
-          attr_reader node: Parser::AST::Node
-
-          include Equatable
-
-          def initialize: (keyword: Symbol?, node: Parser::AST::Node) -> void
-
-          def key_node: () -> Parser::AST::Node?
-
-          def value_node: () -> Parser::AST::Node?
-        end
-
-        class MissingKeyword
-          attr_reader keywords: Set[Symbol]
-
-          include Equatable
-
-          def initialize: (keywords: Set[Symbol]) -> void
-        end
-
-        type arg = ArgTypePairs | SplatArg | error_arg
-
-        type error_arg = UnexpectedKeyword | MissingKeyword
-
-        attr_reader kwarg_nodes: Array[Parser::AST::Node]
-
-        attr_reader keyword_params: Interface::Function::Params::KeywordParams
-
-        attr_reader index: Integer
-
-        attr_reader consumed_keywords: Set[Symbol]
-
-        def initialize: (
-          kwarg_nodes: Array[Parser::AST::Node],
-          keyword_params: Interface::Function::Params::KeywordParams,
-          ?index: ::Integer,
-          ?consumed_keywords: Set[Symbol]
-        ) -> void
-
-        def update: (?index: Integer, ?consumed_keywords: Set[Symbol]) -> KeywordArgs
-
-        def keyword_pair: () -> Parser::AST::Node?
-
-        def required_keywords: () -> Hash[Symbol, AST::Types::t]
-
-        def optional_keywords: () -> Hash[Symbol, AST::Types::t]
-
-        %a{pure} def rest_type: () -> AST::Types::t?
-
-        def keyword_type: (Symbol key) -> AST::Types::t?
-
-        def all_keys: () -> Array[Symbol]
-
-        def all_values: () -> Array[AST::Types::t]
-
-        def possible_key_type: () -> AST::Types::t
-
-        def possible_value_type: () -> AST::Types::t
-
-        def next: () -> [arg, KeywordArgs]?
-
-        def consume_keys: (Array[Symbol] keys, node: Parser::AST::Node) -> [UnexpectedKeyword | Array[AST::Types::t], KeywordArgs]
-      end
-
-      class BlockPassArg
-        attr_reader node: Parser::AST::Node?
-
-        attr_reader block: Interface::Block?
-
-        def initialize: (node: Parser::AST::Node?, block: Interface::Block?) -> void
-
-        include Equatable
-
-        def no_block?: () -> bool
-
-        def compatible?: () -> bool
-
-        def block_missing?: () -> boolish
-
-        def unexpected_block?: () -> boolish
-
-        def pair: () -> [Parser::AST::Node, Interface::Function]?
-
-        def node_type: () -> AST::Types::t
-      end
-
-      class ForwardedArgs
-        attr_reader node: Parser::AST::Node
-
-        attr_reader params: Interface::Function::Params
-
-        def initialize: (node: Parser::AST::Node, params: Interface::Function::Params) -> void
-      end
-
-      attr_reader node: Parser::AST::Node
-
-      attr_reader arguments: Array[Parser::AST::Node]
-
-      attr_reader type: Interface::MethodType | AST::Types::Proc
-
-      def initialize: (node: Parser::AST::Node, arguments: Array[Parser::AST::Node], type: Interface::MethodType | AST::Types::Proc) -> void
-
-      attr_reader params (): Interface::Function::Params
-
-      attr_reader block (): Interface::Block?
-
-      def positional_params: () -> Interface::Function::Params::PositionalParams?
-
-      def keyword_params: () -> Interface::Function::Params::KeywordParams
-
-      def kwargs_node: () -> Parser::AST::Node?
-
-      def forwarded_args_node: () -> Parser::AST::Node?
-
-      def positional_arg: () -> PositionalArgs
-
-      def keyword_args: () -> KeywordArgs
-
-      def block_pass_arg: () -> BlockPassArg
-
-      def each: () { (PositionalArgs::arg | KeywordArgs::arg) -> void } -> [ForwardedArgs?, Array[Diagnostic::Ruby::Base]]
-              | () -> Enumerator[PositionalArgs::arg | KeywordArgs::arg, [ForwardedArgs?, Array[Diagnostic::Ruby::Base]]]
-    end
-  end
-end