steep 1.7.0.dev.4 → 1.7.0

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/case_when.rbs

@@ -1,130 +0,0 @@
-use Parser::AST::Node
-use Steep::TypeConstruction::Pair, Steep::TypeInference::LogicTypeInterpreter::Result
-use Steep::NodeHelper::condition_loc, Steep::NodeHelper::keyword_loc
-
-module Steep
-  module TypeInference
-    class CaseWhen
-      class WhenPatterns
-        include NodeHelper
-
-        attr_reader logic: LogicTypeInterpreter
-
-        attr_reader initial_constr: TypeConstruction
-
-        # True if the `when` clause is unreachable
-        attr_reader unreachable_clause: bool
-
-        @assignment_node: Node
-
-        attr_reader pattern_results: Array[[Node, Result, Result]]
-
-        def initialize: (LogicTypeInterpreter logic, TypeConstruction initial_constr, bool unreachable, Node assignment_node) -> void
-
-        def add_pattern: (Node pattern) { (Node, TypeConstruction, bool) -> Pair } -> void
-
-        # The result for body of the when-clause
-        #
-        # Raises an error when no patern is registered.
-        #
-        def body_result: () { (TypeEnv) -> TypeEnv? } -> [TypeConstruction, bool]
-
-        # The result for next when-clause
-        #
-        # Raises an error when no patern is registered.
-        #
-        def falsy_result: () -> [TypeConstruction, bool]
-
-        # The result for incoming pattern
-        def latest_result: () -> [TypeConstruction, bool]
-
-        # Returns new object equivalent to @assignment_node
-        def assignment_node: () -> Node
-      end
-
-      type when_result = [
-        Result,   # Type of the body of the when-clause
-        Result    # Result for the case the when-clause doesn't match
-      ]
-
-      include NodeHelper
-      extend NodeHelper
-
-      # The location of `#node`
-      attr_reader location: condition_loc
-
-      # `case` node
-      attr_reader node: Node
-
-      attr_reader condition_node: Node
-
-      attr_reader when_nodes: Array[Node]
-
-      attr_reader else_node: Node?
-
-      attr_reader logic: LogicTypeInterpreter
-
-      attr_reader clause_results: Array[when_result]
-
-      attr_reader else_result: Pair?
-
-      # Fresh local variable name that contains the value of `#condition_node`
-      attr_reader var_name: Symbol
-
-      # `lvasgn` node that propagates the value of `#condition_node` to local variables
-      attr_reader assignment_node: Node
-
-      # A node that points to the value of `#condition_node`
-      #
-      # `nil` if it is an local variable.
-      #
-      attr_reader value_node: Node?
-
-      # The result of the type checking of `#condition_node`
-      #
-      attr_reader initial_constr: TypeConstruction
-
-      # The public API
-      #
-      # It type checks given `case` node with condition node, and records types and errors of sub nodes.
-      #
-      def self.type_check: (TypeConstruction, Node, LogicTypeInterpreter, hint: AST::Types::t?, condition: bool) -> [Array[AST::Types::t], Array[TypeEnv]]
-
-      def initialize: (Node, LogicTypeInterpreter) { (Node) -> Pair } -> void
-
-      def when_clauses: () { (WhenPatterns, Array[Node], Node?, keyword_loc) -> when_result } -> void
-
-      def else_clause: () { (Node, TypeConstruction) -> Pair } -> void
-
-      def result: () -> [Array[AST::Types::t], Array[TypeEnv]]
-
-      # Assign type of `value_node`
-      def propagate_value_node_type: (TypeEnv) -> TypeEnv?
-
-      # Returns `true` is `else` keyword is given
-      #
-      # `else_node` may be `nil` because body expression might be omitted.
-      #
-      # ```ruby
-      # case x
-      # when 1
-      # else
-      #   # The body expression is omitted, but the branch is given.
-      # end
-      # ```
-      #
-      def has_else_clause?: () -> Parser::Source::Range?
-
-      # def typing: () -> Typing
-
-      # Extract assignments
-      #
-      # Returns a pair of the node that represents the value and assignment.
-      #
-      def rewrite_condition_node: (Symbol, Node) ->[Node?, Node]
-
-      # TypeConstruction for incoming clause
-      def latest_result: () -> [TypeConstruction, 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,216 +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?
-
-        @upper_bounds: Hash[Symbol, 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