steep 1.5.0.pre.4 → 1.5.0.pre.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfb1de89ec50042cf06306ab17717671e8b6a8451ea2885b4af8085226f7994e
-  data.tar.gz: 1b67eb25821061afe42c8c4dd644b30370e866ac9ef8066cb77031799c981145
+  metadata.gz: ed79428764aa83fbd2e7f3c5a8e52ff863b4e65bef05aae43ba9ca4b7c9d2f4e
+  data.tar.gz: be79772ce19f152e3048ae565802640cae96f1bfca98adf60eab47a28ab3ccad
 SHA512:
-  metadata.gz: 1f0b3400822be747c45ed1d5c2cdfbddf8c0fdf70963061b66308464a18a95e493cc94ad406bbc444f618f562e0f95f276600c27e3ec2269f01504727b0528c7
-  data.tar.gz: 45b2a32802ea5ab504a8c3ee04f714a87b27227ffa66282d64243e3161aa0628001f1925e3ad7aaf09fcd0fbddc4def36e9b9940c76a87b195c2f51b19006bf9
+  metadata.gz: aa071be8eaf425a2a36ffed4c8d0a97446997f9cbf85c9dc4190b5bf26c9bf5f66c7106ab27b96378d05e246a6327689ef491dedbd16ad7cb9eb8d8079b3818d
+  data.tar.gz: d7f842d51c84a2f48bdfd79a07de3e6265dd746497aa9661871f12b062832c2a24f46b37ce1ddb614ac5ba1c65f4c408e9e1eafec27fd69d7158514fe77e0fec

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 1.5.0.pre.5 (2023-07-07)
+
+### Type checker core
+
+* Unreachability improvements ([#845](https://github.com/soutaro/steep/pull/845))
+* Fix type inference problem ([#843](https://github.com/soutaro/steep/pull/843))
+
 ## 1.5.0.pre.4 (2023-07-06)
 
 ### Type checker core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.5.0.pre.4)
+    steep (1.5.0.pre.5)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)

data/lib/steep/ast/types/factory.rb

@@ -204,7 +204,7 @@ module Steep
           when Logic::Base
             RBS::Types::Bases::Bool.new(location: type.location)
           else
-            __skip__ = raise "Unexpected type given: #{type} (#{type.class})"
+            raise "Unexpected type given: #{type} (#{type.class})"
           end
         end
 

data/lib/steep/diagnostic/ruby.rb

@@ -767,6 +767,19 @@ module Steep
         end
       end
 
+      class UnreachableValueBranch < Base
+        attr_reader :type
+
+        def initialize(node:, type:, location: node.location.expression)
+          super(node: node, location: location)
+          @type = type
+        end
+
+        def header_line
+          "The branch may evaluate to a value of `#{type}` but unreachable"
+        end
+      end
+
       class UnexpectedSplat < Base
         attr_reader :type
 
@@ -968,7 +981,8 @@ module Steep
           {
             ImplicitBreakValueMismatch => :warning,
             FallbackAny => :information,
-            UnreachableBranch => :warning,
+            UnreachableValueBranch => :warning,
+            UnreachableBranch => :information,
             UnknownConstant => :warning,
             MethodDefinitionMissing => :information,
             FalseAssertion => :information,
@@ -989,6 +1003,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
+            UnreachableValueBranch => nil,
             UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,
@@ -1006,6 +1021,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
+            UnreachableValueBranch => nil,
             UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,

data/lib/steep/type_construction.rb

@@ -1883,9 +1883,25 @@ module Steep
 
             if truthy.unreachable
               if true_clause
+                _, _, _, loc = deconstruct_if_node!(node)
+
+                if loc.respond_to?(:keyword)
+                  condition_loc = loc #: NodeHelper::condition_loc
+                  case condition_loc.keyword.source
+                  when "if"
+                    location = condition_loc.begin || condition_loc.keyword
+                  when "unless"
+                    # `else` token always exists
+                    location = condition_loc.else || raise
+                  end
+                else
+                  location = true_clause.loc.expression
+                end
+
                 typing.add_error(
                   Diagnostic::Ruby::UnreachableBranch.new(
-                    node: true_clause || node
+                    node: true_clause,
+                    location: location || raise
                   )
                 )
               end
@@ -1893,9 +1909,25 @@ module Steep
 
             if falsy.unreachable
               if false_clause
+                _, _, _, loc = deconstruct_if_node!(node)
+
+                if loc.respond_to?(:keyword)
+                  condition_loc = loc #: NodeHelper::condition_loc
+                  case condition_loc.keyword.source
+                  when "if"
+                    # `else` token always exists
+                    location = condition_loc.else || raise
+                  when "unless"
+                    location = condition_loc.begin || condition_loc.keyword
+                  end
+                else
+                  location = false_clause.loc.expression
+                end
+
                 typing.add_error(
                   Diagnostic::Ruby::UnreachableBranch.new(
-                    node: false_clause || node
+                    node: false_clause,
+                    location: location || raise
                   )
                 )
               end
@@ -1961,19 +1993,25 @@ module Steep
                 next_branch_reachable &&= false_branch_reachable
                 body_constr = when_constr.update_type_env {|env| env.join(*test_envs) }
 
-                if body
-                  branch_results <<
+                branch_result =
+                  if body
                     body_constr
                       .for_branch(body)
                       .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
                       .synthesize(body, hint: hint)
-                else
-                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
-                end
+                  else
+                    Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
+                  end
 
-                unless branch_reachable
+                branch_results << branch_result
+
+                if !branch_reachable && !branch_result.type.is_a?(AST::Types::Bot)
                   typing.add_error(
-                    Diagnostic::Ruby::UnreachableBranch.new(node: body || clause)
+                    Diagnostic::Ruby::UnreachableValueBranch.new(
+                      node: clause,
+                      type: branch_result.type,
+                      location: clause.location.keyword
+                    )
                   )
                 end
 
@@ -2004,9 +2042,14 @@ module Steep
                 # `else` may present even if it's empty
                 if loc.else
                   if els
-                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: els)
-                  else
-                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: node, location: loc.else)
+                    else_result or raise
+                    unless else_result.type.is_a?(AST::Types::Bot)
+                      typing.add_error Diagnostic::Ruby::UnreachableValueBranch.new(
+                        node: els,
+                        type: else_result.type,
+                        location: node.loc.else || raise
+                      )
+                    end
                   end
                 end
               else
@@ -2042,21 +2085,29 @@ module Steep
                   branch_reachable ||= !truthy.unreachable
                 end
 
-                if body
-                  branch_results <<
+                branch_result =
+                  if body
                     when_clause_constr
                       .for_branch(body)
                       .update_type_env {|env| env.join(*body_envs) }
                       .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
                       .synthesize(body, hint: hint)
-                else
-                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
-                end
+                  else
+                    Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
+                  end
+
+                branch_results << branch_result
 
                 unless branch_reachable
-                  typing.add_error(
-                    Diagnostic::Ruby::UnreachableBranch.new(node: body || when_clause)
-                  )
+                  unless branch_result.type.is_a?(AST::Types::Bot)
+                    typing.add_error(
+                      Diagnostic::Ruby::UnreachableValueBranch.new(
+                        node: when_clause,
+                        type: branch_result.type,
+                        location: when_clause.location.keyword || raise
+                      )
+                    )
+                  end
                 end
               end
 
@@ -3913,13 +3964,15 @@ module Steep
             end
 
             if hint && !fvs.empty?
-              if check_relation(sub_type: method_type.type.return_type, super_type: hint, constraints: constraints).success?
-                method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) do
-                  constraints.solution(checker, variables: fvs, context: ccontext)
+              if hint.free_variables.subset?(self_type.free_variables)
+                if check_relation(sub_type: method_type.type.return_type, super_type: hint, constraints: constraints).success?
+                  method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) do
+                    constraints.solution(checker, variables: fvs, context: ccontext)
+                  end
                 end
-              end
 
-              method_type.block or raise
+                method_type.block or raise
+              end
             end
 
             # Method accepts block

data/lib/steep/type_inference/context.rb

@@ -126,7 +126,9 @@ module Steep
 
         def upper_bounds
           table.each_value.with_object({}) do |type_param, bounds|
-            bounds[type_param.name] = type_param.upper_bound
+            if type_param.upper_bound
+              bounds[type_param.name] = type_param.upper_bound
+            end
           end
         end
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.5.0.pre.4"
+  VERSION = "1.5.0.pre.5"
 end

data/sig/shims/parser/nodes.rbs

@@ -62,6 +62,11 @@ module Parser
       %a{pure} def end: () -> Source::Range?
     end
 
+    # ```ruby
+    # foo ? bar : baz
+    # #   ^               question
+    # #         ^         colon
+    # ```
     interface _Ternary
       %a{pure} def question: () -> Source::Range
 

data/sig/steep/diagnostic/ruby.rbs

@@ -479,6 +479,31 @@ module Steep
         def header_line: () -> String
       end
 
+      # The branch is unreachable, but not `bot` type
+      #
+      # We often have `else` branch to make the code more defensive:
+      #
+      # ```ruby
+      # case value
+      # when Integer
+      #   # ...
+      # when String
+      #   # ...
+      # else
+      #   raise "Cannot happen!"
+      # end
+      # ```
+      #
+      # This diagnostic allows writing `raise` or `return`, by checking the type of the branch body is `bot` or not.
+      # 
+      class UnreachableValueBranch < Base
+        attr_reader type: AST::Types::t
+
+        def initialize: (node: Parser::AST::Node, type: AST::Types::t, ?location: location) -> void
+
+        def header_line: () -> String
+      end
+
       class UnexpectedSplat < Base
         attr_reader type: untyped
 

data/smoke/diagnostics/test_expectations.yml

@@ -120,18 +120,6 @@
     message: 'The method parameter has different kind from the declaration `(name:
       ::String, size: ::Integer) -> void`'
     code: Ruby::DifferentMethodParameterKind
-- file: else_on_exhaustive_case.rb
-  diagnostics:
-  - range:
-      start:
-        line: 11
-        character: 2
-      end:
-        line: 11
-        character: 26
-    severity: ERROR
-    message: The branch is unreachable
-    code: Ruby::UnreachableBranch
 - file: incompatible_annotation.rb
   diagnostics:
   - range:

data/smoke/type_case/test_expectations.yml

@@ -13,14 +13,14 @@
     code: Ruby::NoMethod
   - range:
       start:
-        line: 12
-        character: 2
+        line: 11
+        character: 0
       end:
-        line: 12
-        character: 10
+        line: 11
+        character: 4
     severity: ERROR
-    message: The branch is unreachable
-    code: Ruby::UnreachableBranch
+    message: The branch may evaluate to a value of `untyped` but unreachable
+    code: Ruby::UnreachableValueBranch
   - range:
       start:
         line: 12

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.5.0.pre.4
+  version: 1.5.0.pre.5
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-06 00:00:00.000000000 Z
+date: 2023-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser