steep 1.1.1 → 1.2.0.pre.1

data/sig/steep/type_inference/context.rbs

@@ -2,21 +2,28 @@ module Steep
   module TypeInference
     class Context
       class MethodContext
-        attr_reader name: untyped
+        attr_reader name: Symbol?
 
-        attr_reader method: untyped
+        attr_reader method: RBS::Definition::Method?
 
-        attr_reader method_type: untyped
+        attr_reader method_type: Interface::MethodType?
 
-        attr_reader return_type: untyped
+        attr_reader return_type: AST::Types::t
 
-        attr_reader constructor: untyped
+        attr_reader constructor: bool
 
-        attr_reader super_method: untyped
+        attr_reader super_method: RBS::Definition::Method?
 
-        def initialize: (name: untyped, method: untyped, method_type: untyped, return_type: untyped, constructor: untyped, super_method: untyped) -> void
+        def initialize: (
+          name: Symbol,
+          method: RBS::Definition::Method?,
+          method_type: Interface::MethodType?,
+          return_type: AST::Types::t,
+          constructor: bool,
+          super_method: RBS::Definition::Method?
+        ) -> void
 
-        def block_type: () -> untyped
+        def block_type: () -> Interface::Block?
       end
 
       class BlockContext
@@ -62,15 +69,33 @@ module Steep
 
         attr_reader class_name: RBS::TypeName
 
-        attr_reader instance_definition: RBS::Definition
-
-        attr_reader module_definition: RBS::Definition
-
-        def initialize: (instance_type: untyped, module_type: untyped, implement_name: untyped, class_name: untyped, nesting: untyped, ?instance_definition: untyped?, ?module_definition: untyped?) -> void
-
-        def class_variables: () -> (untyped | nil)
-
-        def update: (?instance_type: untyped, ?module_type: untyped, ?implement_name: untyped, ?class_name: untyped, ?instance_definition: untyped, ?module_definition: untyped, ?nesting: untyped) -> untyped
+        attr_reader instance_definition: RBS::Definition?
+
+        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: untyped,
+          class_name: RBS::TypeName,
+          nesting: RBS::Resolver::context,
+          ?instance_definition: RBS::Definition?,
+          ?module_definition: RBS::Definition?
+        ) -> void
+
+        def class_variables: () -> Hash[Symbol, RBS::Types::t]?
+
+        def update: (
+          ?instance_type: AST::Types::t,
+          ?module_type: AST::Types::t,
+          ?implement_name: untyped,
+          ?class_name: RBS::TypeName,
+          ?instance_definition: RBS::Definition?,
+          ?module_definition: RBS::Definition?,
+          ?nesting: RBS::Resolver::context
+        ) -> ModuleContext
       end
 
       class TypeVariableContext
@@ -99,7 +124,7 @@ module Steep
 
       attr_reader break_context: BreakContext?
 
-      attr_reader module_context: untyped
+      attr_reader module_context: ModuleContext?
 
       attr_reader self_type: AST::Types::t
 
@@ -111,7 +136,7 @@ module Steep
         method_context: untyped,
         block_context: BlockContext?,
         break_context: BreakContext?,
-        module_context: untyped,
+        module_context: ModuleContext?,
         self_type: untyped,
         type_env: TypeEnv,
         call_context: untyped,
@@ -122,7 +147,7 @@ module Steep
         ?method_context: untyped,
         ?block_context: BlockContext?,
         ?break_context: BreakContext?,
-        ?module_context: untyped,
+        ?module_context: ModuleContext?,
         ?self_type: untyped,
         ?type_env: TypeEnv,
         ?call_context: untyped,

data/sig/steep/type_inference/context_array.rbs

@@ -0,0 +1,37 @@
+module Steep
+  module TypeInference
+    class ContextArray
+      class Entry
+        attr_reader range: untyped
+
+        attr_reader context: untyped
+
+        attr_reader sub_entries: untyped
+
+        def initialize: (range: untyped, context: untyped) -> void
+      end
+
+      attr_reader buffer: untyped
+
+      attr_reader root: untyped
+
+      def initialize: (buffer: untyped, context: untyped, ?range: untyped) -> void
+
+      def range: () -> untyped
+
+      def self.from_source: (source: untyped, ?range: untyped?, ?context: untyped?) -> untyped
+
+      def insert_context: (untyped range, context: untyped, ?entry: untyped) -> untyped
+
+      def each_entry: () { (untyped) -> untyped } -> untyped
+
+      def context_at: (untyped index, ?entry: untyped) -> (nil | untyped)
+
+      def []: (untyped index) -> untyped
+
+      def at: (line: untyped, column: untyped) -> untyped
+
+      def merge: (untyped subtree) -> untyped
+    end
+  end
+end

data/sig/steep/type_inference/logic_type_interpreter.rbs

@@ -7,7 +7,9 @@ module Steep
 
       attr_reader factory (): AST::Types::Factory
 
-      def initialize: (subtyping: Subtyping::Check, typing: Typing) -> void
+      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) -> [TypeEnv, TypeEnv, Set[Symbol | Parser::AST::Node], AST::Types::t, AST::Types::t]
 

data/sig/steep/type_inference/method_params.rbs

@@ -45,7 +45,7 @@ module Steep
         alias eql? ==
 
         def hash: () -> Integer
-        
+
         def var_type: () -> AST::Types::t
       end
 
@@ -58,23 +58,27 @@ module Steep
       end
 
       class BlockParameter
-        attr_reader name: untyped
+        attr_reader name: Symbol
 
-        attr_reader type: untyped
+        attr_reader type: Interface::Function?
+
+        attr_reader node: Parser::AST::Node
 
-        attr_reader node: untyped
+        attr_reader self_type: AST::Types::t?
 
-        def initialize: (name: untyped, type: untyped, node: untyped, optional: untyped) -> void
+        def initialize: (name: Symbol, type: Interface::Function?, node: Parser::AST::Node, optional: boolish, self_type: AST::Types::t?) -> void
 
-        def optional?: () -> (true | false)
+        @optional: boolish
+
+        def optional?: () -> bool
 
         def var_type: () -> AST::Types::t
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
         alias eql? ==
 
-        def hash: () -> untyped
+        def hash: () -> Integer
       end
 
       attr_reader args: untyped
@@ -94,7 +98,7 @@ module Steep
       def each_param: () { (BaseParameter | BaseRestParameter | BlockParameter) -> void } -> void
                     | () -> Enumerator[BaseParameter | BaseRestParameter | BlockParameter, void]
 
-      def each: () { (Symbol, BaseRestParameter | BaseRestParameter | BlockParameter) -> void } -> void
+      def each: () { (Symbol, AST::Types::t) -> void } -> void
 
       def self.empty: (node: Parser::AST::Node) -> MethodParams
 

data/sig/steep/type_inference/send_args.rbs

@@ -0,0 +1,229 @@
+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 | 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]
+
+        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 | 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
+
+      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 positional_arg: () -> PositionalArgs
+
+      def keyword_args: () -> KeywordArgs
+
+      def block_pass_arg: () -> BlockPassArg
+
+      def each: () { (PositionalArgs::arg | KeywordArgs::arg) -> void } -> Array[Diagnostic::Ruby::Base]
+              | () -> Enumerator[PositionalArgs::arg | KeywordArgs::arg, Array[Diagnostic::Ruby::Base]]
+    end
+  end
+end

data/sig/steep/type_inference/type_env_builder.rbs

@@ -69,7 +69,7 @@ module Steep
 
       attr_reader commands: Array[Command::_Base]
 
-      def initialize: (*Command::_Base) -> void
+      def initialize: (*Command::_Base?) -> void
 
       def build: (TypeEnv) -> TypeEnv
     end

data/sig/steep/typing.rbs

@@ -10,11 +10,11 @@ module Steep
 
     attr_reader source: Source
 
-    attr_reader errors: untyped
+    attr_reader errors: Array[Diagnostic::Ruby::Base]
 
-    attr_reader typing: untyped
+    attr_reader typing: Hash[Parser::AST::Node, AST::Types::t]
 
-    attr_reader parent: untyped
+    attr_reader parent: Typing?
 
     attr_reader parent_last_update: untyped
 
@@ -32,7 +32,7 @@ module Steep
 
     def initialize: (source: untyped, root_context: untyped, ?parent: untyped?, ?parent_last_update: untyped, ?contexts: untyped?, ?source_index: untyped?) -> void
 
-    def add_error: (untyped error) -> untyped
+    def add_error: (Diagnostic::Ruby::Base error) -> void
 
     def add_typing: (Parser::AST::Node node, AST::Types::t `type`, TypeInference::Context _context) -> untyped
 

data/sig/steep.rbs

@@ -1,5 +1,5 @@
 module Steep
-  def self.logger: () -> Logger
+  def self.logger: () -> (Logger & ActiveSupport::TaggedLogging)
 
   def self.new_logger: (untyped output, untyped prev_level) -> untyped
 
@@ -7,10 +7,12 @@ module Steep
 
   def self.log_output=: (untyped output) -> untyped
 
-  def self.measure: (untyped message, ?level: ::Symbol) { () -> untyped } -> untyped
+  def self.measure: [A] (String message, ?level: ::Symbol) { () -> A } -> A
 
   def self.log_error: (untyped exn, ?message: ::String) -> untyped
 
+  self.@logger: ActiveSupport::TaggedLogging?
+
   class Sampler
     def initialize: () -> void
 

data/smoke/block/e.rb

@@ -0,0 +1,12 @@
+123.instance_eval do
+  self - 1
+end
+
+b = BlockWithSelf.new.instance_exec do
+  @name = ""
+  @id = 123
+end
+
+[1, ""][0].instance_eval do
+  foo()
+end

data/smoke/block/e.rbs

@@ -0,0 +1,4 @@
+class BlockWithSelf
+  @name: String
+  @id: Integer
+end

data/smoke/block/test_expectations.yml

@@ -123,3 +123,15 @@
         def map: [U] () { (::Integer) -> U } -> ::Array[U]
                | () -> ::Enumerator[::Integer, ::Array[untyped]]
     code: Ruby::UnresolvedOverloading
+- file: e.rb
+  diagnostics:
+  - range:
+      start:
+        line: 11
+        character: 2
+      end:
+        line: 11
+        character: 5
+    severity: ERROR
+    message: Type `(::Integer | ::String)` does not have method `foo`
+    code: Ruby::NoMethod

data/smoke/regression/block_param_split.rb

@@ -0,0 +1,7 @@
+# @type var a: Array[BlockParamSplit::pair[Integer, String]]
+a = [[1, "a"]]
+
+a.each do |x, y|
+  x + 1
+  y + "2"
+end

data/smoke/regression/block_param_split.rbs

@@ -0,0 +1,3 @@
+module BlockParamSplit
+  type pair[T, S] = [T, S]
+end

data/smoke/regression/empty_yield.rb

@@ -0,0 +1,5 @@
+class EmptyYield
+  def foo
+    yield
+  end
+end

data/smoke/regression/empty_yield.rbs

@@ -0,0 +1,3 @@
+class EmptyYield
+  def foo: () { (Integer) -> void } -> void
+end

data/smoke/regression/test_expectations.yml

@@ -11,6 +11,18 @@
     severity: ERROR
     message: 'Cannot find the declaration of class: `Foo`'
     code: Ruby::UnknownConstant
+- file: empty_yield.rb
+  diagnostics:
+  - range:
+      start:
+        line: 3
+        character: 4
+      end:
+        line: 3
+        character: 9
+    severity: ERROR
+    message: More positional arguments are required
+    code: Ruby::InsufficientPositionalArguments
 - file: hash.rb
   diagnostics:
   - range:

data/smoke/yield/test_expectations.yml

@@ -35,11 +35,11 @@
         character: 11
     severity: ERROR
     message: |-
-      Cannot assign a value of type `::String` to an expression of type `::Integer`
+      Cannot pass a value of type `::String` as an argument of type `::Integer`
         ::String <: ::Integer
           ::Object <: ::Integer
             ::BasicObject <: ::Integer
-    code: Ruby::IncompatibleAssignment
+    code: Ruby::ArgumentTypeMismatch
   - range:
       start:
         line: 13
@@ -81,8 +81,8 @@
         character: 12
     severity: ERROR
     message: |-
-      Cannot assign a value of type `::String` to an expression of type `::Integer`
+      Cannot pass a value of type `::String` as an argument of type `::Integer`
         ::String <: ::Integer
           ::Object <: ::Integer
             ::BasicObject <: ::Integer
-    code: Ruby::IncompatibleAssignment
+    code: Ruby::ArgumentTypeMismatch

data/steep.gemspec

@@ -33,7 +33,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", ">= 3.15", "< 4.0"
-  spec.add_runtime_dependency "rbs", ">= 2.3.2"
+  spec.add_runtime_dependency "rbs", ">= 2.7.0.pre"
   spec.add_runtime_dependency "parallel", ">= 1.0.0"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 4"
+  spec.add_runtime_dependency "securerandom", ">= 0.1"
 end