steep 1.6.0 → 1.7.1

data/sig/steep/type_inference/block_params.rbs

@@ -1,170 +0,0 @@
-module Steep
-  module TypeInference
-    # Block parameters have the following differences from method parameters:
-    #
-    # * Allows arity mismatch
-    # * Distributing array-ish argument to parameters
-    # * Allows _multiple_ parameter assignments
-    #
-    # ### Allows arity mismatch
-    #
-    # (TBD)
-    #
-    # ### Distributing array-ish argument to parameters
-    #
-    # A block can receive an array(-ish) argument as follows:
-    # Assume `yield [1,2,3]` evaluates to call the block.
-    #
-    # 1. With one parameter `{|x| ... }` (`x` is `[1, 2, 3]`)
-    # 2. With several parameters (splatting) `{|x, y, z| ... }` (`x` is `1`, ...)
-    #
-    # The splatting applies only when one argument that is an array-ish is yielded.
-    #
-    # Because we have another rule which allows parameter omission, Ruby has another rule to avoid ambiguity.
-    #
-    # 3. One parameter with trailing comma splats `{|x,| ... }` (`x` is `1`)
-    #
-    # The parser has `:procarg0` node for case 1 and `arg` nodes for other cases.
-    #
-    # ### Allows _multiple_ parameter assignments
-    #
-    class BlockParams
-      # Param object represents a block parameter
-      #
-      # * `var` is name of the parameter
-      # * `type` is the type of the parameter, if given through inline annotation
-      # * `value` is the default value node
-      # * `node` is the node of the parameter
-      #
-      class Param
-        attr_reader var: Symbol
-
-        attr_reader type: AST::Types::t?
-
-        attr_reader value: Parser::AST::Node?
-
-        attr_reader node: Parser::AST::Node
-
-        def initialize: (var: Symbol, type: AST::Types::t?, value: Parser::AST::Node?, node: Parser::AST::Node) -> void
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def hash: () -> Integer
-
-        def each_param: () { (Param) -> void } -> void
-                      | () -> Enumerator[Param, void]
-      end
-
-      # MultipleParam object represents a _multiple_ block parameter
-      #
-      # ```ruby
-      # foo do |(x, y)|
-      #   #     ^^^^^^  This is the multiple block parameter
-      # end
-      # ```
-      #
-      # * `#node` is `:mlhs` node or `:procarg0` node
-      # * Param objects in `#params` don't have `value` because of Ruby syntax rule
-      #
-      class MultipleParam
-        attr_reader node: Parser::AST::Node
-
-        attr_reader params: Array[Param | MultipleParam]
-
-        def initialize: (node: Parser::AST::Node, params: Array[Param | MultipleParam]) -> void
-
-        def ==: (untyped other) -> bool
-
-        alias eql? ==
-
-        def hash: () -> Integer
-
-        # Returns a hash table that associates variables to its type annotation
-        #
-        def variable_types: () -> Hash[Symbol, AST::Types::t?]
-
-        # Yields Param objects in `self` and it's `params` recursively
-        #
-        def each_param: () { (Param) -> void } -> void
-                      | () -> Enumerator[Param, void]
-
-        # Type that is constructed from `#params` type annotations
-        #
-        # Returns `nil` any part of the params is left un-annotated.
-        #
-        def type: () -> AST::Types::t?
-      end
-
-      attr_reader leading_params: Array[Param | MultipleParam]
-
-      attr_reader optional_params: Array[Param]
-
-      attr_reader rest_param: Param?
-
-      attr_reader trailing_params: Array[Param | MultipleParam]
-
-      attr_reader block_param: Param?
-
-      def initialize: (
-        leading_params: Array[Param | MultipleParam],
-        optional_params: Array[Param],
-        rest_param: Param?,
-        trailing_params: Array[Param | MultipleParam],
-        block_param: Param?
-      ) -> void
-
-      def params: () -> Array[Param | MultipleParam]
-
-      def self.from_node: (Parser::AST::Node node, annotations: AST::Annotation::Collection) -> BlockParams
-
-      def self.from_multiple: (Parser::AST::Node node, AST::Annotation::Collection) -> MultipleParam
-
-      def params_type: (?hint: Interface::Function::Params?) -> Interface::Function::Params
-
-      def params_type0: (hint: nil) -> Interface::Function::Params
-                      | (hint: Interface::Function::Params?) -> Interface::Function::Params?
-
-      def zip: (
-        Interface::Function::Params params_type,
-        Interface::Block? block,
-        factory: AST::Types::Factory
-      ) -> Array[[Param | MultipleParam, AST::Types::t]]
-
-      # Returns true if given possible block yields are subject to auto expand/splat
-      #
-      # ```rbs
-      # { (Array[String]) -> void }      # Array[String]
-      # { ([Integer, String]) -> void }  # [Integer, String]
-      # { (String) -> void }             # nil
-      # ```
-      #
-      def expandable_params?: (Interface::Function::Params params_type, AST::Types::Factory) -> AST::Types::t?
-
-      # Returns true if the block is defined to expand/splat automatically
-      #
-      # ```ruby
-      # foo {|x, y| ... }   # true  (has multiple parameters)
-      # foo {|x, *x| ... }  # true  (has normal and rest parameters)
-      # foo {|x,| ... }     # true s(:arg, :x) (has one parameter with trailing comma)
-      # foo {|x| ... }      # false s(:procarg0, s(:arg :x))
-      # ```
-      #
-      def expandable?: () -> bool
-
-      def each: () { (Param | MultipleParam) -> void } -> void
-              | () -> Enumerator[Param | MultipleParam, void]
-
-      # Yields `Param` recursively
-      #
-      def each_single_param: () { (Param) -> void } -> void
-
-      # Returns true if the parameter is single `untyped`
-      #
-      # This will automatically distribute `untyped` on block parameters.
-      #
-      def untyped_args?: (Interface::Function::Params) -> bool
-    end
-  end
-end

data/sig/steep/type_inference/constant_env.rbs

@@ -1,29 +0,0 @@
-module Steep
-  module TypeInference
-    class ConstantEnv
-      type constant_tuple = [untyped, RBS::TypeName, RBS::Constant::constant_entry]
-
-      attr_reader context: RBS::Resolver::context
-
-      attr_reader factory: AST::Types::Factory
-
-      attr_reader resolver: RBS::Resolver::ConstantResolver
-
-      def initialize: (factory: AST::Types::Factory, context: RBS::Resolver::context, resolver: RBS::Resolver::ConstantResolver) -> void
-
-      def resolve: (Symbol name) -> constant_tuple?
-
-      def toplevel: (Symbol name) -> constant_tuple?
-
-      def constants: () -> Hash[Symbol, constant_tuple]
-
-      def resolve_child: (RBS::TypeName module_name, Symbol constant_name) -> constant_tuple?
-
-      def children: (RBS::TypeName module_name) -> Hash[Symbol, constant_tuple]
-
-      def decompose_constant!: (RBS::Constant? constant) -> constant_tuple
-
-      def decompose_constant: (RBS::Constant? constant) -> constant_tuple?
-    end
-  end
-end

data/sig/steep/type_inference/context.rbs

@@ -1,214 +0,0 @@
-use Steep::Interface::Function::Params, Steep::Interface::Block
-
-module Steep
-  module TypeInference
-    # Type checking context
-    class Context
-      # Information about the method which the body is being type checked
-      #
-      class MethodContext
-        # Name of the method
-        attr_reader name: Symbol
-
-        # `nil` when RBS doesn't have the corresponding method definition
-        attr_reader method: RBS::Definition::Method?
-
-        # `nil` when no method type is given
-        attr_reader method_type: Interface::MethodType?
-
-        # Falls back to `untyped`
-        attr_reader return_type: AST::Types::t
-
-        # The *super* method if identified
-        attr_reader super_method: RBS::Definition::Method?
-
-        # The type of forwarding params when `...` is given
-        attr_reader forward_arg_type: [Params, Block?]?
-
-        def initialize: (
-          name: Symbol,
-          method: RBS::Definition::Method?,
-          method_type: Interface::MethodType?,
-          return_type: AST::Types::t,
-          super_method: RBS::Definition::Method?,
-          forward_arg_type: [Params, Block?]?
-        ) -> void
-
-        # Type of the block of the current method type
-        def block_type: () -> Interface::Block?
-
-        # Returns `true` if the method is a setter -- ends with `=`
-        #
-        def attribute_setter?: () -> bool
-      end
-
-      # Information about the block which the body is being type checked
-      #
-      class BlockContext
-        # The type of block itself
-        #
-        # Returns `nil` if no type is specified.
-        #
-        attr_reader body_type: AST::Types::t?
-
-        def initialize: (body_type: AST::Types::t?) -> void
-
-        def subst: (Interface::Substitution) -> BlockContext
-      end
-
-      # Context about the `break` syntax
-      class BreakContext
-        # Type of arguments to `break` statement
-        #
-        attr_reader break_type: AST::Types::t
-
-        # Type of arguments to `next` statement
-        #
-        # `nil` means the passed value will be ignored.
-        #
-        attr_reader next_type: AST::Types::t?
-
-        def initialize: (break_type: AST::Types::t, next_type: AST::Types::t?) -> void
-
-        def subst: (Interface::Substitution) -> BreakContext
-      end
-
-      # Information about the module which the body is being type checked
-      #
-      class ModuleContext
-        # The type of an instance of current module
-        attr_reader instance_type: AST::Types::t
-
-        # The type of singleton of current module
-        attr_reader module_type: AST::Types::t
-
-        # The set of name of instance methods that is defined in the `module`/`class` statement
-        attr_reader defined_instance_methods: Set[Symbol]
-
-        # The set of name of singleton methods that is defined in the `module`/`class` statement
-        attr_reader defined_module_methods: Set[Symbol]
-
-        # The nesting of current module
-        #
-        # Cannot be `nil`.
-        #
-        attr_reader nesting: RBS::Resolver::context
-
-        # The name that is given to `@implements` annotation
-        #
-        # `nil` when no `@implements` annotation is given.
-        #
-        attr_reader implement_name: AST::Annotation::Implements::Module?
-
-        # The name of the class/module.
-        attr_reader class_name: RBS::TypeName
-
-        # The definition of the instance of the module
-        attr_reader instance_definition: RBS::Definition?
-
-        # The definition of the singleton of the module
-        attr_reader module_definition: RBS::Definition?
-
-        @class_variables: Hash[Symbol, RBS::Types::t]?
-
-        def initialize: (
-          instance_type: AST::Types::t,
-          module_type: AST::Types::t,
-          implement_name: AST::Annotation::Implements::Module?,
-          class_name: RBS::TypeName,
-          nesting: RBS::Resolver::context,
-          ?instance_definition: RBS::Definition?,
-          ?module_definition: RBS::Definition?
-        ) -> void
-
-        # Returns a hash from the name of a class variable to its type
-        %a{pure} def class_variables: () -> Hash[Symbol, RBS::Types::t]?
-
-        def update: (
-          ?instance_type: AST::Types::t,
-          ?module_type: AST::Types::t,
-          ?implement_name: AST::Annotation::Implements::Module?,
-          ?class_name: RBS::TypeName,
-          ?instance_definition: RBS::Definition?,
-          ?module_definition: RBS::Definition?,
-          ?nesting: RBS::Resolver::context
-        ) -> ModuleContext
-      end
-
-      # Information about the free type variables
-      #
-      class TypeVariableContext
-        attr_reader table: Hash[Symbol, Interface::TypeParam]
-
-        attr_reader type_params: Array[Interface::TypeParam]
-
-        def initialize: (Array[Interface::TypeParam] type_params, ?parent_context: TypeVariableContext?) -> void
-
-        # Returns the upper bound of a type variable
-        def []: (Symbol name) -> AST::Types::t?
-
-        def upper_bounds: () -> Hash[Symbol, AST::Types::t]
-
-        def self.empty: () -> TypeVariableContext
-      end
-
-      # The caller where a method is called from
-      attr_reader call_context: MethodCall::context
-
-      # MethodContext for current execution point
-      #
-      # `nil` when not in any method definition.
-      #
-      attr_reader method_context: MethodContext?
-
-      # BlockContext for current execution point
-      #
-      # `nil` when not in iterator block.
-      #
-      attr_reader block_context: BlockContext?
-
-      # BreakContext for current execution point
-      #
-      # `nil` if `break` is not allowed.
-      #
-      attr_reader break_context: BreakContext?
-
-      # ModuleContext for current execution point
-      attr_reader module_context: ModuleContext
-
-      # The type of `self`
-      #
-      attr_reader self_type: AST::Types::t
-
-      attr_reader type_env: TypeEnv
-
-      attr_reader variable_context: TypeVariableContext
-
-      def initialize: (
-        method_context: MethodContext?,
-        block_context: BlockContext?,
-        break_context: BreakContext?,
-        module_context: ModuleContext,
-        self_type: AST::Types::t,
-        type_env: TypeEnv,
-        call_context: MethodCall::context,
-        variable_context: TypeVariableContext
-      ) -> void
-
-      def with: (
-        ?method_context: MethodContext?,
-        ?block_context: BlockContext?,
-        ?break_context: BreakContext?,
-        ?module_context: ModuleContext,
-        ?self_type: AST::Types::t,
-        ?type_env: TypeEnv,
-        ?call_context: MethodCall::context,
-        ?variable_context: TypeVariableContext
-      ) -> Context
-
-      def factory: () -> AST::Types::Factory
-
-      def env: () -> RBS::Environment
-    end
-  end
-end

data/sig/steep/type_inference/context_array.rbs

@@ -1,38 +0,0 @@
-module Steep
-  module TypeInference
-    class ContextArray
-      class Entry
-        attr_reader range: Range[Integer]
-
-        attr_reader context: Context
-
-        attr_reader sub_entries: Set[Entry]
-
-        def initialize: (range: Range[Integer], context: Context) -> void
-      end
-
-      attr_reader buffer: RBS::Buffer
-
-      attr_reader root: Entry
-
-      def initialize: (buffer: RBS::Buffer, context: Context, ?range: Range[Integer]) -> void
-
-      def range: () -> Range[Integer]
-
-      def self.from_source: (source: Source, ?range: Range[Integer]?, context: Context) -> ContextArray
-
-      def insert_context: (Range[Integer] range, context: Context, ?entry: Entry) -> void
-
-      def each_entry: () { (Entry) -> void } -> void
-                    | () -> Enumerator[Entry, void]
-
-      def context_at: (Integer index, ?entry: Entry) -> Context?
-
-      def []: (Integer index) -> Context?
-
-      def at: (line: Integer, column: Integer) -> Context?
-
-      def merge: (ContextArray subtree) -> void
-    end
-  end
-end

data/sig/steep/type_inference/logic_type_interpreter.rbs

@@ -1,108 +0,0 @@
-module Steep
-  module TypeInference
-    class LogicTypeInterpreter
-      class Result
-        attr_reader env: TypeEnv
-
-        attr_reader type: AST::Types::t
-
-        attr_accessor unreachable: bool
-
-        def initialize: (env: TypeEnv, type: AST::Types::t, unreachable: bool) -> void
-
-        def update_env: () { () -> TypeEnv } -> Result
-
-        def update_type: { () -> AST::Types::t } -> Result
-
-        # Make the instance unreachable, and returns self
-        #
-        def unreachable!: () -> self
-      end
-
-      TRUE: AST::Types::Literal
-
-      FALSE: AST::Types::Literal
-
-      BOOL: AST::Types::Boolean
-
-      BOT: AST::Types::Bot
-
-      UNTYPED: AST::Types::Any
-
-      attr_reader subtyping: Subtyping::Check
-
-      attr_reader typing: Typing
-
-      attr_reader factory (): AST::Types::Factory
-
-      attr_reader config: Interface::Builder::Config
-
-      def initialize: (subtyping: Subtyping::Check, typing: Typing, config: Interface::Builder::Config) -> void
-
-      def eval: (env: TypeEnv, node: Parser::AST::Node) -> [Result, Result]
-
-      def evaluate_node: (env: TypeEnv, node: Parser::AST::Node, ?type: AST::Types::t) -> [Result, Result]
-
-      def evaluate_method_call: (env: TypeEnv, type: AST::Types::Logic::Base, receiver: Parser::AST::Node?, arguments: Array[Parser::AST::Node]) -> [Result, Result]?
-
-      # Apply type refinement to `node` as `truthy_type` and `falsy_type`.
-      #
-      # This is done by top-down manner.
-      #
-      # Assignes given two types to the node when:
-      #
-      # * `node` is a `lvar`
-      # * `node` is a `lvasgn`
-      # * `node` is a _pure_ method call
-      #
-      def refine_node_type: (env: TypeEnv, node: Parser::AST::Node, truthy_type: AST::Types::t, falsy_type: AST::Types::t) -> [TypeEnv, TypeEnv]
-
-      # Returns a pair of a node and set of local variable names.
-      #
-      # * The returned node is called _value node_ that is a node the value of given `node` can be taken from
-      # * The local variable names are local variables that have the same value of the _value node_.
-      #
-      # ```ruby
-      # a = 123   # `123` is the _value node_
-      #           # :a is included in the set because `a` has the same value of _value node_
-      #
-      # c = b = a  # `a` is the _value node_, a set of { :b, :c } will be returned
-      # ```
-      #
-      def decompose_value: (Parser::AST::Node node) -> [Parser::AST::Node, Set[Symbol]]
-
-      private
-
-      # Assign local variables included in the assignment node and masgn node
-      #
-      def evaluate_assignment: (Parser::AST::Node node, TypeEnv env, AST::Types::t rhs_type) -> TypeEnv
-
-      def guess_type_from_method: (Parser::AST::Node node) -> (AST::Types::Logic::ReceiverIsArg | AST::Types::Logic::ReceiverIsNil | AST::Types::Logic::Not | AST::Types::Logic::ArgIsReceiver | nil)
-
-      # Decompose to given type to truthy and falsy types.
-      #
-      # This directly corresponds to case-when syntax with literals:
-      #
-      # ```ruby
-      # case x
-      # when nil       # value_node == {nil}, arg_type = type_of({x})
-      #   ...
-      # when 123       # value_node == {nil}, arg_type = type_of({x})
-      #   ...
-      # end
-      # ```
-      #
-      def literal_var_type_case_select: (Parser::AST::Node value_node, AST::Types::t arg_type) -> [Array[AST::Types::t], Array[AST::Types::t]]?
-
-      def type_case_select: (AST::Types::t `type`, RBS::TypeName klass) -> [AST::Types::t?, AST::Types::t?]
-
-      def type_case_select0: (AST::Types::t `type`, RBS::TypeName klass) -> [Array[AST::Types::t], Array[AST::Types::t]]
-
-      def try_convert: (AST::Types::t, Symbol) -> AST::Types::t?
-
-      def no_subtyping?: (sub_type: AST::Types::t, super_type: AST::Types::t) -> Subtyping::Result::t?
-
-      def subtyping?: (sub_type: AST::Types::t, super_type: AST::Types::t) -> bool
-    end
-  end
-end

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