steep 1.8.0.pre.2 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ee676b84b4cf51568f84ecc88f1ec50591f2ee0b45b435ce3eafd4416c07193
-  data.tar.gz: 86b23102cdbe3dd578a25b14d5ab1d8240cdf201124ad9342fa24bfe8baedfca
+  metadata.gz: 1619c69c7c85bbe5f0dffc4826aabf3e5a4ffa46c4eba61bab5a47ef29957d65
+  data.tar.gz: 25540890ecd3d6b7dfa2cd280c65da59b7ec65e520942fa09175908d3bfe124a
 SHA512:
-  metadata.gz: 8f20566852d2a4815e5fdfc4e2756cd11c530326e59488268d707781c615a2e5f2987aecc0a5e705f737b1099a78849a7f84e879a086c1a4f578d6259aa000c3
-  data.tar.gz: cdd82bc25963caee0195a35a9c8255f3e34d3b6cf2ffae9a34c5fe0affd0b32cab6c04071adf73d8a86ef9538de14d2a8a6420939e0fa67de3725ff8aeab779e
+  metadata.gz: 3715058e9bf76839a0072e3f5e01fbcce25913e0a23b03ae645644b8c88f0f5160264ce3aa989c391a3b81ee04c7104670f0c77ce3c8192a847909c6f4e8fa9d
+  data.tar.gz: 759e541a4444b02c2c86a8adbab2c606e667010c427146d4e74a61d422ddd55ce70ef30953d1ad94a7f1afea0a216f9e6198ffab71693b0bb7370819cc52707e

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 1.8.1 (2024-10-08)
+
+### Language server
+
+* Skip sending response to `$/steep/typecheck` request from `steep langserver` ([#1268](https://github.com/soutaro/steep/pull/1268), backport [#1267](https://github.com/soutaro/steep/pull/1267))
+
+## 1.8.0 (2024-09-30)
+
+### Type checker core
+
+* RBS validation ([#1239](https://github.com/soutaro/steep/pull/1239))
+* Add special path for `Kernel#class` method ([#1229](https://github.com/soutaro/steep/pull/1229))
+
 ## 1.8.0.pre.2 (2024-09-18)
 
 ### Type checker core

data/lib/steep/ast/builtin.rb

@@ -65,6 +65,7 @@ module Steep
       Regexp = Type.new("::Regexp")
       NilClass = Type.new("::NilClass")
       Proc = Type.new("::Proc")
+      Kernel = Type.new("::Kernel")
 
       def self.nil_type
         AST::Types::Nil.instance

data/lib/steep/diagnostic/result_printer2.rb

@@ -0,0 +1,48 @@
+module Steep
+  module Diagnostic
+    module ResultPrinter2
+      def result_line(result)
+        case result
+        when Subtyping::Result::Failure
+          case result.error
+          when Subtyping::Result::Failure::UnknownPairError
+            nil
+          when Subtyping::Result::Failure::UnsatisfiedConstraints
+            "Unsatisfied constraints: #{result.relation}"
+          when Subtyping::Result::Failure::MethodMissingError
+            "Method `#{result.error.name}` is missing"
+          when Subtyping::Result::Failure::BlockMismatchError
+            "Incomaptible block: #{result.relation}"
+          when Subtyping::Result::Failure::ParameterMismatchError
+            if result.relation.params?
+              "Incompatible arity: #{result.relation.super_type} and #{result.relation.sub_type}"
+            else
+              "Incompatible arity: #{result.relation}"
+            end
+          when Subtyping::Result::Failure::PolyMethodSubtyping
+            "Unsupported polymorphic method comparison: #{result.relation}"
+          when Subtyping::Result::Failure::SelfBindingMismatch
+            "Incompatible block self type: #{result.relation}"
+          end
+        else
+          result.relation.to_s
+        end
+      end
+
+      def detail_lines
+        lines = StringIO.new.tap do |io|
+          failure_path = result.failure_path || []
+          failure_path.reverse_each.filter_map do |result|
+            result_line(result)
+          end.each.with_index(1) do |message, index|
+            io.puts "#{"  " * (index)}#{message}"
+          end
+        end.string.chomp
+
+        unless lines.empty?
+          lines
+        end
+      end
+    end
+  end
+end

data/lib/steep/diagnostic/ruby.rb

@@ -61,51 +61,6 @@ module Steep
         end
       end
 
-      module ResultPrinter2
-        def result_line(result)
-          case result
-          when Subtyping::Result::Failure
-            case result.error
-            when Subtyping::Result::Failure::UnknownPairError
-              nil
-            when Subtyping::Result::Failure::UnsatisfiedConstraints
-              "Unsatisfied constraints: #{result.relation}"
-            when Subtyping::Result::Failure::MethodMissingError
-              "Method `#{result.error.name}` is missing"
-            when Subtyping::Result::Failure::BlockMismatchError
-              "Incomaptible block: #{result.relation}"
-            when Subtyping::Result::Failure::ParameterMismatchError
-              if result.relation.params?
-                "Incompatible arity: #{result.relation.super_type} and #{result.relation.sub_type}"
-              else
-                "Incompatible arity: #{result.relation}"
-              end
-            when Subtyping::Result::Failure::PolyMethodSubtyping
-              "Unsupported polymorphic method comparison: #{result.relation}"
-            when Subtyping::Result::Failure::SelfBindingMismatch
-              "Incompatible block self type: #{result.relation}"
-            end
-          else
-            result.relation.to_s
-          end
-        end
-
-        def detail_lines
-          lines = StringIO.new.tap do |io|
-            failure_path = result.failure_path || []
-            failure_path.reverse_each.filter_map do |result|
-              result_line(result)
-            end.each.with_index(1) do |message, index|
-              io.puts "#{"  " * (index)}#{message}"
-            end
-          end.string.chomp
-
-          unless lines.empty?
-            lines
-          end
-        end
-      end
-
       class IncompatibleAssignment < Base
         attr_reader :lhs_type
         attr_reader :rhs_type

data/lib/steep/diagnostic/signature.rb

@@ -105,12 +105,16 @@ module Steep
         attr_reader :type_name
         attr_reader :type_arg
         attr_reader :type_param
+        attr_reader :result
 
-        def initialize(type_name:, type_arg:, type_param:, location:)
+        include ResultPrinter2
+
+        def initialize(type_name:, type_arg:, type_param:, result:, location:)
           super(location: location)
           @type_name = type_name
           @type_arg = type_arg
           @type_param = type_param
+          @result = result
         end
 
         def header_line
@@ -248,14 +252,20 @@ module Steep
       class ModuleSelfTypeError < Base
         attr_reader :name
         attr_reader :ancestor
-        attr_reader :relation
+        attr_reader :result
+
+        include ResultPrinter2
 
-        def initialize(name:, ancestor:, relation:, location:)
+        def initialize(name:, ancestor:, result:, location:)
           super(location: location)
 
           @name = name
           @ancestor = ancestor
-          @relation = relation
+          @result = result
+        end
+
+        def relation
+          result.relation
         end
 
         def header_line
@@ -417,6 +427,40 @@ module Steep
         end
       end
 
+      class TypeParamDefaultReferenceError < Base
+        attr_reader :type_param
+
+        def initialize(type_param, location:)
+          super(location: location)
+          @type_param = type_param
+        end
+
+        def header_line
+          "The default type of `#{type_param.name}` cannot depend on optional type parameters"
+        end
+      end
+
+      class UnsatisfiableGenericsDefaultType < Base
+        attr_reader :param_name, :result
+
+        include ResultPrinter2
+
+        def initialize(param_name, result, location:)
+          super(location: location)
+          @param_name = param_name
+          @result = result
+        end
+
+        def relation
+          result.relation
+        end
+
+        def header_line
+          "The default type of `#{param_name}` doesn't satisfy upper bound constarint: #{relation}"
+        end
+      end
+
+
       def self.from_rbs_error(error, factory:)
         case error
         when RBS::ParsingError
@@ -515,6 +559,8 @@ module Steep
           Diagnostic::Signature::InconsistentClassModuleAliasError.new(decl: error.alias_entry.decl)
         when RBS::CyclicClassAliasDefinitionError
           Diagnostic::Signature::CyclicClassAliasDefinitionError.new(decl: error.alias_entry.decl)
+        when RBS::TypeParamDefaultReferenceError
+          Diagnostic::Signature::TypeParamDefaultReferenceError.new(error.type_param, location: error.location)
         else
           raise error
         end

data/lib/steep/drivers/checkfile.rb

@@ -165,6 +165,7 @@ module Steep
           request.signature_paths << project.absolute_path(path)
         end
 
+        request.needs_response = true
         master.start_type_check(request: request, last_request: nil, report_progress_threshold: 0)
 
         Steep.logger.info { "Starting type checking: #{request_guid}" }

data/lib/steep/drivers/stats.rb

@@ -162,7 +162,7 @@ module Steep
         master.job_queue << -> do
           Steep.logger.info { "Type checking for stats..." }
           progress = master.work_done_progress(typecheck_guid)
-          master.start_type_check(last_request: nil, progress: progress, include_unchanged: true, report_progress_threshold: 0)
+          master.start_type_check(last_request: nil, progress: progress, include_unchanged: true, report_progress_threshold: 0, needs_response: true)
         end
         wait_for_message(reader: client_reader) do |message|
           message[:id] == typecheck_guid

data/lib/steep/interface/builder.rb

@@ -281,6 +281,7 @@ module Steep
                 method_name = method_name_for(type_def, name)
                 method_type = factory.method_type(type_def.type)
                 method_type = replace_primitive_method(method_name, type_def, method_type)
+                method_type = replace_kernel_class(method_name, type_def, method_type) { AST::Builtin::Class.instance_type }
                 Shape::MethodOverload.new(method_type, [type_def])
               end
 
@@ -311,6 +312,9 @@ module Steep
                 method_name = method_name_for(type_def, name)
                 method_type = factory.method_type(type_def.type)
                 method_type = replace_primitive_method(method_name, type_def, method_type)
+                if type_name.class?
+                  method_type = replace_kernel_class(method_name, type_def, method_type) { AST::Types::Name::Singleton.new(name: type_name) }
+                end
                 Shape::MethodOverload.new(method_type, [type_def])
               end
 
@@ -748,7 +752,7 @@ module Steep
                     return_type: AST::Types::Logic::ReceiverIsNil.instance()
                   )
                 )
-            end
+              end
             end
 
           when :!
@@ -801,6 +805,23 @@ module Steep
 
         method_type
       end
+
+      def replace_kernel_class(method_name, method_def, method_type)
+        defined_in = method_def.defined_in
+        member = method_def.member
+
+        if member.is_a?(RBS::AST::Members::MethodDefinition)
+          case method_name.method_name
+          when :class
+            case defined_in
+            when AST::Builtin::Kernel.module_name
+              return method_type.with(type: method_type.type.with(return_type: yield))
+            end
+          end
+        end
+
+        method_type
+      end
     end
   end
 end

data/lib/steep/server/master.rb

@@ -12,6 +12,7 @@ module Steep
         attr_reader :checked_paths
         attr_reader :work_done_progress
         attr_reader :started_at
+        attr_accessor :needs_response
 
         def initialize(guid:, progress:)
           @guid = guid
@@ -22,6 +23,7 @@ module Steep
           @checked_paths = Set[]
           @work_done_progress = progress
           @started_at = Time.now
+          @needs_response = false
         end
 
         def uri(path)
@@ -732,7 +734,8 @@ module Steep
                   start_type_check(
                     last_request: last_request,
                     include_unchanged: true,
-                    progress: work_done_progress(guid)
+                    progress: work_done_progress(guid),
+                    needs_response: false
                   )
                 end
               )
@@ -755,7 +758,8 @@ module Steep
 
                     start_type_check(
                       last_request: last_request,
-                      progress: work_done_progress(guid)
+                      progress: work_done_progress(guid),
+                      needs_response: false
                     )
                   end
                 )
@@ -859,7 +863,8 @@ module Steep
           start_type_check(
             last_request: current_type_check_request,
             include_unchanged: true,
-            progress: work_done_progress(guid || SecureRandom.uuid)
+            progress: work_done_progress(guid || SecureRandom.uuid),
+            needs_response: true
           )
 
         when "$/ping"
@@ -920,25 +925,27 @@ module Steep
         finished_at = Time.now
         duration = finished_at - request.started_at
 
-        enqueue_write_job(
-          SendMessageJob.to_client(
-            message: CustomMethods::TypeCheck.response(
-              request.guid,
-              {
-                guid: request.guid,
-                completed: request.finished?,
-                started_at: request.started_at.iso8601,
-                finished_at: finished_at.iso8601,
-                duration: duration.to_i
-              }
+        if request.needs_response
+          enqueue_write_job(
+            SendMessageJob.to_client(
+              message: CustomMethods::TypeCheck.response(
+                request.guid,
+                {
+                  guid: request.guid,
+                  completed: request.finished?,
+                  started_at: request.started_at.iso8601,
+                  finished_at: finished_at.iso8601,
+                  duration: duration.to_i
+                }
+              )
             )
           )
-        )
-
-        nil
+        else
+          Steep.logger.debug { "Skip sending response to #{CustomMethods::TypeCheck::METHOD} request" }
+        end
       end
 
-      def start_type_check(request: nil, last_request:, progress: nil, include_unchanged: false, report_progress_threshold: 10)
+      def start_type_check(request: nil, last_request:, progress: nil, include_unchanged: false, report_progress_threshold: 10, needs_response: nil)
         Steep.logger.tagged "#start_type_check(#{progress&.guid || request&.guid}, #{last_request&.guid}" do
           if last_request
             finish_type_check(last_request)
@@ -947,6 +954,7 @@ module Steep
           unless request
             progress or raise
             request = controller.make_request(guid: progress.guid, include_unchanged: include_unchanged, progress: progress) or return
+            request.needs_response = needs_response ? true : false
           end
 
           if request.total > report_progress_threshold
@@ -960,7 +968,8 @@ module Steep
             end
 
             if request.finished?
-              @current_type_check_request = finish_type_check(request)
+              finish_type_check(request)
+              @current_type_check_request = nil
               return
             end
           else
@@ -992,7 +1001,8 @@ module Steep
             current.work_done_progress.report(percentage, "#{percentage}%")
 
             if current.finished?
-              @current_type_check_request = finish_type_check(current)
+              finish_type_check(current)
+              @current_type_check_request = nil
             end
           end
         end

data/lib/steep/signature/validator.rb

@@ -104,6 +104,7 @@ module Steep
                     unchecked: param.unchecked?,
                     default_type: factory.type_opt(param.default_type)
                   ),
+                  result: result,
                   location: location
                 )
               end
@@ -252,6 +253,39 @@ module Steep
         end
       end
 
+      def validate_type_params(type_name, type_params)
+        if error_type_params = RBS::AST::TypeParam.validate(type_params)
+          error_type_params.each do |type_param|
+            default_type = type_param.default_type or raise
+            @errors << Diagnostic::Signature::TypeParamDefaultReferenceError.new(type_param, location: default_type.location)
+          end
+        end
+
+        upper_bounds = type_params.each.with_object({}) do |param, bounds| #$ Hash[Symbol, AST::Types::t?]
+          bounds[param.name] = factory.type_opt(param.upper_bound_type)
+        end
+
+        checker.push_variable_bounds(upper_bounds) do
+          type_params.each do |type_param|
+            param = checker.factory.type_param(type_param)
+
+            default_type = param.default_type or next
+            upper_bound = param.upper_bound or next
+
+            relation = Subtyping::Relation.new(sub_type: default_type, super_type: upper_bound)
+            result = checker.check(relation, self_type: nil, instance_type: nil, class_type: nil, constraints: Subtyping::Constraints.empty)
+
+            if result.failure?
+              @errors << Diagnostic::Signature::UnsatisfiableGenericsDefaultType.new(
+                type_param.name,
+                result,
+                location: (type_param.default_type || raise).location
+              )
+            end
+          end
+        end
+      end
+
       def validate_one_class_decl(name, entry)
         rescue_validation_errors(name) do
           Steep.logger.debug { "Validating class definition `#{name}`..." }
@@ -310,7 +344,7 @@ module Steep
                         name: name,
                         location: ancestor.source&.location || raise,
                         ancestor: ancestor,
-                        relation: relation
+                        result: _1
                       )
                     end
                   end
@@ -405,7 +439,7 @@ module Steep
                       name: name,
                       location: ancestor.source&.location || raise,
                       ancestor: ancestor,
-                      relation: relation
+                      result: _1
                     )
                   end
                 end
@@ -419,6 +453,8 @@ module Steep
                 validate_definition_type(definition)
               end
             end
+
+            validate_type_params(name, entry.type_params)
           end
         end
       end
@@ -480,6 +516,8 @@ module Steep
           Steep.logger.tagged "#{name}" do
             definition = builder.build_interface(name)
 
+            validate_type_params(name, definition.type_params_decl)
+
             upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
               bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end
@@ -575,6 +613,8 @@ module Steep
               builder.validate_type_name(outer, entry.decl.location&.aref(:name))
             end
 
+            validate_type_params(name, entry.decl.type_params)
+
             upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
               bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end

data/lib/steep/type_construction.rb

@@ -2657,34 +2657,11 @@ module Steep
     def synthesize_sendish(node, hint:, tapp:)
       case node.type
       when :send
-        yield_self do
-          if self_class?(node)
-            module_type = expand_alias(module_context.module_type)
-            type = if module_type.is_a?(AST::Types::Name::Singleton)
-                     AST::Types::Name::Singleton.new(name: module_type.name)
-                   else
-                     module_type
-                   end
-
-            add_typing(node, type: type)
-          else
-            type_send(node, send_node: node, block_params: nil, block_body: nil, tapp: tapp, hint: hint)
-          end
-        end
+        type_send(node, send_node: node, block_params: nil, block_body: nil, tapp: tapp, hint: hint)
       when :csend
         yield_self do
           send_type, constr =
-            if self_class?(node)
-              module_type = expand_alias(module_context.module_type)
-              type = if module_type.is_a?(AST::Types::Name::Singleton)
-                       AST::Types::Name::Singleton.new(name: module_type.name)
-                     else
-                       module_type
-                     end
-              add_typing(node, type: type).to_ary
-            else
-              type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true, tapp: tapp, hint: hint).to_ary
-            end
+            type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true, tapp: tapp, hint: hint).to_ary
 
           constr
             .update_type_env { context.type_env.join(constr.context.type_env, context.type_env) }
@@ -4687,10 +4664,6 @@ module Steep
       add_typing node, type: AST::Builtin.any_type
     end
 
-    def self_class?(node)
-      node.type == :send && node.children[0]&.type == :self && node.children[1] == :class
-    end
-
     def namespace_module?(node)
       # @type var nodes: Array[Parser::AST::Node]
       nodes =

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.8.0.pre.2"
+  VERSION = "1.8.1"
 end

data/lib/steep.rb

@@ -75,6 +75,7 @@ require "steep/subtyping/constraints"
 require "steep/subtyping/variable_variance"
 
 require "steep/diagnostic/helper"
+require "steep/diagnostic/result_printer2"
 require "steep/diagnostic/ruby"
 require "steep/diagnostic/signature"
 require "steep/diagnostic/lsp_formatter"

data/sample/sig/generics.rbs

@@ -0,0 +1,15 @@
+module LocationHelper : _WithLocation
+  interface _WithLocation
+    def location_method: () -> String
+  end
+
+  def hello: () -> void
+end
+
+class StringGeneric[X < Integer, Y < Integer = String]
+  def location_method: () -> Integer
+
+  include LocationHelper
+  extend LocationHelper
+end
+

data/steep.gemspec

@@ -36,7 +36,7 @@ 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", "~> 3.6.0.pre"
+  spec.add_runtime_dependency "rbs", "~> 3.6.0"
   spec.add_runtime_dependency "concurrent-ruby", ">= 1.1.10"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 4"
   spec.add_runtime_dependency "securerandom", ">= 0.1"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.8.0.pre.2
+  version: 1.8.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-18 00:00:00.000000000 Z
+date: 2024-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -98,14 +98,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.6.0.pre
+        version: 3.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.6.0.pre
+        version: 3.6.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -291,6 +291,7 @@ files:
 - lib/steep/diagnostic/deprecated/unknown_constant_assigned.rb
 - lib/steep/diagnostic/helper.rb
 - lib/steep/diagnostic/lsp_formatter.rb
+- lib/steep/diagnostic/result_printer2.rb
 - lib/steep/diagnostic/ruby.rb
 - lib/steep/diagnostic/signature.rb
 - lib/steep/drivers/annotations.rb
@@ -384,6 +385,7 @@ files:
 - sample/lib/conference.rb
 - sample/lib/length.rb
 - sample/sig/conference.rbs
+- sample/sig/generics.rbs
 - sample/sig/length.rbs
 - steep.gemspec
 homepage: https://github.com/soutaro/steep
@@ -408,7 +410,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: Gradual Typing for Ruby