steep 1.6.0 → 1.7.1

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?]?
-
-      def initialize: (args: Array[Node], method_type: MethodType?, forward_arg_type: [Params, Block?]?) -> 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?]?) -> 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

data/sig/steep/type_inference/type_env.rbs

@@ -1,160 +0,0 @@
-module Steep
-  module TypeInference
-    # TypeEnv is the one-stop class to manage type of variables.
-    #
-    # ### Local variables primitive operations
-    #
-    # * Assigning to a local variable
-    # * Adding local variable type enforcement
-    # * Refine local variable types
-    # * Resetting refinements
-    #
-    # ### Pure calls primitive operations
-    #
-    # * Adding pure calls
-    # * Removing pure calls
-    # * Refine pure call types
-    # * Resetting pure call refinements
-    #
-    # ### Branch operations
-    #
-    # * Start branching with refinements
-    # * Merge branches
-    #
-    #
-    class TypeEnv
-      include NodeHelper
-
-      type local_variable_entry = [AST::Types::t, AST::Types::t?]
-
-      attr_reader local_variable_types: Hash[Symbol, local_variable_entry]
-
-      attr_reader pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-
-      attr_reader instance_variable_types: Hash[Symbol, AST::Types::t]
-
-      attr_reader global_types: Hash[Symbol, AST::Types::t]
-
-      attr_reader constant_types: Hash[RBS::TypeName, AST::Types::t]
-
-      attr_reader constant_env: ConstantEnv
-
-      @pure_node_descendants: Hash[Parser::AST::Node, Set[Parser::AST::Node]]
-
-      def initialize: (
-          ConstantEnv,
-          ?local_variable_types: Hash[Symbol, local_variable_entry],
-          ?instance_variable_types: Hash[Symbol, AST::Types::t],
-          ?global_types: Hash[Symbol, AST::Types::t],
-          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
-          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-        ) -> void
-
-      def update: (
-          ?local_variable_types: Hash[Symbol, local_variable_entry],
-          ?instance_variable_types: Hash[Symbol, AST::Types::t],
-          ?global_types: Hash[Symbol, AST::Types::t],
-          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
-          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-        ) -> TypeEnv
-
-      def merge: (
-          ?local_variable_types: Hash[Symbol, local_variable_entry],
-          ?instance_variable_types: Hash[Symbol, AST::Types::t],
-          ?global_types: Hash[Symbol, AST::Types::t],
-          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
-          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-        ) -> TypeEnv
-
-      # Returns type of `name`.
-      #
-      def []: (Symbol name) -> AST::Types::t?
-            | (Parser::AST::Node node) -> AST::Types::t?
-
-      # Tells the environment that local variables are updated.
-      # Keeps their enforced types and invalidates related nodes.
-      #
-      def assign_local_variables: (Hash[Symbol, AST::Types::t]) -> TypeEnv
-
-      # Tells the environment that the local variable is updated with it's enforced type.
-      #
-      # Invalidates related nodes.
-      #
-      def assign_local_variable: (Symbol name, AST::Types::t type, AST::Types::t? enforced_type) -> TypeEnv
-
-      # Refines types of local variables and pure calls.
-      #
-      # * Receives types of updated local variables and pure calls.
-      # * The local variable types will be
-      #
-      def refine_types: (?local_variable_types: Hash[Symbol, AST::Types::t], ?pure_call_types: Hash[Parser::AST::Node, AST::Types::t]) -> TypeEnv
-
-      def enforced_type: (Symbol name) -> AST::Types::t?
-
-      # Returns type of constant of `const_name`, or `const_name` under `mod_name`.
-      #
-      # Returns `nil` if no such constant found.
-      #
-      def constant: (Symbol const_name, bool toplevel) -> ConstantEnv::constant_tuple?
-                  | (RBS::TypeName mod_name, Symbol const_name) -> ConstantEnv::constant_tuple?
-
-      def annotated_constant: (RBS::TypeName) -> AST::Types::t?
-
-      # _Pin_ the local variables if array is given.
-      # When `nil` is given, all local variables are _pinned_.
-      #
-      def pin_local_variables: (Array[Symbol]? names) -> Hash[Symbol, local_variable_entry]
-
-      # _Unpin_ the local variables if array is given.
-      # When `nil` is given, all local variables are _unpinned_.
-      #
-      def unpin_local_variables: (Array[Symbol]? names) -> TypeEnv
-
-      def to_s: () -> String
-
-      # Apply the substitution to the type of local variables.
-      #
-      def subst: (Interface::Substitution) -> TypeEnv
-
-      # Returns a `TypeEnv` such that:
-      #
-      # * All of the given environments are result of the type checking of branches from `self`,
-      # * All of the branches meet at one point, with the returned `TypeEnv`
-      #
-      # See the example below:
-      #
-      # ```ruby
-      # if foo()         # The original environment `self` is for after the evaluation of `foo()`
-      #   a = bar()      # One environment `env1` can be given from after the evaluation of `bar()`
-      # else
-      #   b = baz()      # Another environment `env2` is from after the evaluation of `baz`
-      # end
-      #
-      # ???              # How is the environment for here is `self.merge(env1, env2)`
-      #                  # The environment has both optional types of `a` and `b`
-      # ```
-      #
-      def join: (*TypeEnv) -> TypeEnv
-
-      def add_pure_call: (Parser::AST::Node, MethodCall::Typed, AST::Types::t?) -> TypeEnv
-
-      def replace_pure_call_type: (Parser::AST::Node, AST::Types::t) -> TypeEnv
-
-      def invalidate_pure_node: (Parser::AST::Node) -> TypeEnv
-
-      private
-
-      def pure_node_invalidation: (Enumerable[Parser::AST::Node] invalidated_nodes) -> Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-
-      def invalidated_pure_nodes: (Parser::AST::Node) -> Set[Parser::AST::Node]
-
-      def local_variable_name?: (Symbol) -> bool
-
-      def local_variable_name!: (Symbol) -> void
-
-      def instance_variable_name?: (Symbol) -> bool
-
-      def global_name?: (Symbol) -> bool
-    end
-  end
-end

data/sig/steep/type_inference/type_env_builder.rbs

@@ -1,81 +0,0 @@
-module Steep
-  module TypeInference
-    class TypeEnvBuilder
-      module Command
-        interface _Base
-          def call: (TypeEnv) -> TypeEnv
-        end
-
-        class RBSBase
-          attr_reader environment: RBS::Environment
-
-          attr_reader factory: AST::Types::Factory
-
-          def initialize: (AST::Types::Factory) -> void
-        end
-
-        class AnnotationsBase
-          attr_reader annotations: AST::Annotation::Collection
-
-          def initialize: (AST::Annotation::Collection) -> void
-        end
-
-        # Insert local variable annotations.
-        #
-        # * When _merge mode_ is on, adds and overwrite local variables.
-        # * When _merge mode_ is off, it wipes all existing local variables and adds from annotations.
-        #
-        class ImportLocalVariableAnnotations < AnnotationsBase
-          include _Base
-
-          attr_reader on_duplicate: (^(Symbol, AST::Types::t, AST::Types::t) -> void)?
-
-          @merge: bool
-
-          # Set _merge mode_ `on`.
-          def merge!: (?bool) -> self
-
-          def on_duplicate!: () { (Symbol name, AST::Types::t original, AST::Types::t annotation) -> void } -> self
-        end
-
-        # Insert global variable types into type environment from `RBS::Environment`.
-        #
-        class ImportGlobalDeclarations < RBSBase
-          def merge!: (?bool) -> self
-
-          @merge: bool
-
-          include _Base
-        end
-
-        class ImportInstanceVariableAnnotations < AnnotationsBase
-          def merge!: (?bool) -> self
-                    
-          include _Base
-
-          @merge: bool
-        end
-
-        class ImportInstanceVariableDefinition
-          attr_reader definition: RBS::Definition?
-
-          attr_reader factory: AST::Types::Factory
-
-          def initialize: (RBS::Definition?, AST::Types::Factory) -> void
-
-          include _Base
-        end
-
-        class ImportConstantAnnotations < AnnotationsBase
-          include _Base
-        end
-      end
-
-      attr_reader commands: Array[Command::_Base]
-
-      def initialize: (*Command::_Base?) -> void
-
-      def build: (TypeEnv) -> TypeEnv
-    end
-  end
-end