steep 1.5.0.pre.2 → 1.5.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6cfc6dc27ad9f1d484bf734c1633319866b9c6f2593237adace2f17562dfe4b
-  data.tar.gz: 05af58e6372461a82e0cfe3984c9694b51bb706236db7a64302e772f476efd9a
+  metadata.gz: cfb1de89ec50042cf06306ab17717671e8b6a8451ea2885b4af8085226f7994e
+  data.tar.gz: 1b67eb25821061afe42c8c4dd644b30370e866ac9ef8066cb77031799c981145
 SHA512:
-  metadata.gz: b3b5f11e9a138fceb039c2fb7970f4fbb0b27344114427267d8d74dfab0050f299a75ee8ff6a7051ef93c353dd73f7eac74d9994f998a07360a6743e7e76a8cf
-  data.tar.gz: d75bf5d4329e11ff68f0d61421b3c9c4cf24406959b084b4042e03210477f53469ae02bfd351834c276c9d46c9237bd4a3054a8c5a8b460e9be6f617a64f034b
+  metadata.gz: 1f0b3400822be747c45ed1d5c2cdfbddf8c0fdf70963061b66308464a18a95e493cc94ad406bbc444f618f562e0f95f276600c27e3ec2269f01504727b0528c7
+  data.tar.gz: 45b2a32802ea5ab504a8c3ee04f714a87b27227ffa66282d64243e3161aa0628001f1925e3ad7aaf09fcd0fbddc4def36e9b9940c76a87b195c2f51b19006bf9

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## master
 
+## 1.5.0.pre.4 (2023-07-06)
+
+### Type checker core
+
+* Fix unreachability test ([#842](https://github.com/soutaro/steep/pull/842))
+* Make type of `case` node `untyped` rather than `nil` ([#841](https://github.com/soutaro/steep/pull/841))
+* Fix `#partition_union` ([#840](https://github.com/soutaro/steep/pull/840))
+* Fix type-case ([#839](https://github.com/soutaro/steep/pull/839))
+
+## 1.5.0.pre.3 (2023-07-05)
+
+### Type checker core
+
+* Resolve type names from TypeAssertion and TypeApplication ([#836](https://github.com/soutaro/steep/pull/836))
+
+### Commandline tool
+
+* Replace ElseOnExhaustiveCase by UnreachableBranch from steep/diagnostic/ruby.rb ([#833](https://github.com/soutaro/steep/pull/833))
+
+### Language server
+
+* Reuse the latest result to keep SignatureHelp opened while typing ([#835](https://github.com/soutaro/steep/pull/835))
+
 ## 1.5.0.pre.2 (2023-07-05)
 
 ### Language server
@@ -21,6 +44,10 @@
 * Fix type assertion parsing error ([#805](https://github.com/soutaro/steep/pull/805))
 * Distribute `untyped` to block params ([#798](https://github.com/soutaro/steep/pull/798))
 * Should escape underscore for method name ([#770](https://github.com/soutaro/steep/pull/770))
+* Give a special typing rule to `#lambda` calls ([#811](https://github.com/soutaro/steep/pull/811))
+* Support early return code using "and return" ([#828](https://github.com/soutaro/steep/pull/828))
+* Validate type applications in ancestors ([#810](https://github.com/soutaro/steep/pull/810))
+* Convert block-pass-arguments with `#to_proc` ([#806](https://github.com/soutaro/steep/pull/806))
 
 ### Commandline tool
 
@@ -38,11 +65,14 @@
 
 * Completion in annotations ([#818](https://github.com/soutaro/steep/pull/818))
 * Implement *go to type definition* ([#784](https://github.com/soutaro/steep/pull/784))
+* completion: Support completion for optional chaining (&.) ([#827](https://github.com/soutaro/steep/pull/827))
+* signature helps are not shown if the target code has comments ([#829](https://github.com/soutaro/steep/pull/829))
 
 ### Miscellaneous
 
 * Typecheck sources ([#820](https://github.com/soutaro/steep/pull/820))
 * Relax concurrent-ruby requirement ([#812](https://github.com/soutaro/steep/pull/812))
+* Cast from union for faster type checking ([#830](https://github.com/soutaro/steep/pull/830))
 
 ## 1.4.0 (2023-04-25)
 

data/Gemfile.lock

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

data/lib/steep/ast/node/type_application.rb

@@ -25,6 +25,8 @@ module Steep
         end
 
         def types(context, subtyping, type_vars)
+          resolver = RBS::Resolver::TypeNameResolver.new(subtyping.factory.env)
+
           # @type var types: Array[Types::t]
           types = []
 
@@ -32,6 +34,7 @@ module Steep
 
           while true
             ty = RBS::Parser.parse_type(loc.buffer, range: loc.range, variables: type_vars) or break
+            ty = ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
 
             validator = Signature::Validator.new(checker: subtyping)
             validator.validate_type(ty)
@@ -41,7 +44,7 @@ module Steep
             end
 
             ty = subtyping.factory.type(ty)
-            types << subtyping.factory.absolute_type(ty, context: context)
+            types << ty
 
             match = RBS::Location.new(loc.buffer, ty.location.end_pos, type_location.end_pos).source.match(/\A\s*,\s*/) or break
             offset = match.length

data/lib/steep/ast/node/type_assertion.rb

@@ -18,12 +18,14 @@ module Steep
 
         def type(context, subtyping, type_vars)
           if ty = RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: type_vars, require_eof: true)
+            resolver = RBS::Resolver::TypeNameResolver.new(subtyping.factory.env)
+            ty = ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
+
             validator = Signature::Validator.new(checker: subtyping)
             validator.validate_type(ty)
 
             unless validator.has_error?
-              ty = subtyping.factory.type(ty)
-              subtyping.factory.absolute_type(ty, context: context)
+              subtyping.factory.type(ty)
             end
           else
             nil

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

@@ -358,16 +358,21 @@ module Steep
               partition_union(unfold)
             end
           when AST::Types::Union
-            falsy_types, truthy_types = type.types.partition do |type|
-              (type.is_a?(AST::Types::Literal) && type.value == false) ||
-                type.is_a?(AST::Types::Nil)
+            truthy_types = [] #: Array[AST::Types::t]
+            falsy_types = [] #: Array[AST::Types::t]
+
+            type.types.each do |type|
+              truthy, falsy = partition_union(type)
+
+              truthy_types << truthy if truthy
+              falsy_types << falsy if falsy
             end
 
             [
               truthy_types.empty? ? nil : AST::Types::Union.build(types: truthy_types),
               falsy_types.empty? ? nil : AST::Types::Union.build(types: falsy_types)
             ]
-          when AST::Types::Any, AST::Types::Boolean
+          when AST::Types::Any, AST::Types::Boolean, AST::Types::Top, AST::Types::Logic::Base
             [type, type]
           when AST::Types::Nil
             [nil, type]

data/lib/steep/diagnostic/ruby.rb

@@ -968,7 +968,7 @@ module Steep
           {
             ImplicitBreakValueMismatch => :warning,
             FallbackAny => :information,
-            ElseOnExhaustiveCase => :warning,
+            UnreachableBranch => :warning,
             UnknownConstant => :warning,
             MethodDefinitionMissing => :information,
             FalseAssertion => :information,
@@ -989,7 +989,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
-            ElseOnExhaustiveCase => nil,
+            UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,
             UnsupportedSyntax => nil,
@@ -1006,7 +1006,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
-            ElseOnExhaustiveCase => nil,
+            UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,
             UnexpectedJump => nil,

data/lib/steep/server/interaction_worker.rb

@@ -406,7 +406,8 @@ module Steep
                 )
               end
 
-              LSP::Interface::SignatureHelp.new(
+              @last_signature_help_line = job.line
+              @last_signature_help_result = LSP::Interface::SignatureHelp.new(
                 signatures: signatures,
                 active_signature: index
               )
@@ -414,7 +415,8 @@ module Steep
           end
         end
       rescue Parser::SyntaxError
-        # Ignore syntax error
+        # Reuse the latest result to keep SignatureHelp opened while typing
+        @last_signature_help_result if @last_signature_help_line == job.line
       end
     end
   end

data/lib/steep/type_construction.rb

@@ -1398,8 +1398,11 @@ module Steep
         when :true, :false
           ty = node.type == :true ? AST::Types::Literal.new(value: true) : AST::Types::Literal.new(value: false)
 
-          if hint && check_relation(sub_type: ty, super_type: hint).success? && !hint.is_a?(AST::Types::Any) && !hint.is_a?(AST::Types::Top)
+          case
+          when hint && check_relation(sub_type: ty, super_type: hint).success? && !hint.is_a?(AST::Types::Any) && !hint.is_a?(AST::Types::Top)
             add_typing(node, type: hint)
+          when condition
+            add_typing(node, type: ty)
           else
             add_typing(node, type: AST::Types::Boolean.new)
           end
@@ -1920,18 +1923,9 @@ module Steep
                 cond_vars.delete(name)
               end
 
-              var_name = :"_a#{SecureRandom.alphanumeric(4)}"
-              var_cond, value_node = extract_outermost_call(cond, var_name)
-              if value_node
-                unless constr.context.type_env[value_node]
-                  constr = constr.update_type_env do |env|
-                    env.assign_local_variable(var_name, cond_type, nil)
-                  end
-                  cond = var_cond
-                else
-                  value_node = nil
-                end
-              end
+              var_name = :"_a[#{SecureRandom.alphanumeric(4)}]"
+              var_cond, value_node = transform_condition_node(cond, var_name)
+              constr = constr.update_type_env {|env| env.assign_local_variable(var_name, cond_type, nil) }
 
               next_branch_reachable = true
 
@@ -1949,12 +1943,12 @@ module Steep
                 false_branch_reachable = false
 
                 tests.each do |test|
-                  test_node = test.updated(:send, [test, :===, cond])
+                  test_node = test.updated(:send, [test, :===, var_cond])
                   test_type, test_constr = test_constr.synthesize(test_node, condition: true).to_ary
                   truthy, falsy = interpreter.eval(node: test_node, env: test_constr.context.type_env)
 
-                  truthy_env = truthy.env
-                  falsy_env = falsy.env
+                  truthy_env = propagate_type_env(var_name, value_node, truthy.env)
+                  falsy_env = propagate_type_env(var_name, value_node, falsy.env)
 
                   test_envs << truthy_env
 
@@ -2003,11 +1997,6 @@ module Steep
               types = branch_results.map(&:type)
               constrs = branch_results.map(&:constr)
 
-              cond_type = when_constr.context.type_env[var_name]
-              cond_type ||= when_constr.context.type_env[cond_vars.first || raise] unless cond_vars.empty?
-              cond_type ||= when_constr.context.type_env[value_node] if value_node
-              cond_type ||= typing.type_of(node: node.children[0])
-
               if !next_branch_reachable
                 # Exhaustive
                 _, _, _, loc = deconstruct_case_node!(node)
@@ -2030,9 +2019,6 @@ module Steep
               branch_results = [] #: Array[Pair]
 
               condition_constr = constr
-              clause_constr = constr
-
-              next_branch_reachable = true
 
               whens.each do |when_clause|
                 when_clause_constr = condition_constr
@@ -2043,7 +2029,6 @@ module Steep
                 *tests, body = when_clause.children
 
                 branch_reachable = false
-                false_branch_reachable = false
 
                 tests.each do |test|
                   test_type, condition_constr = condition_constr.synthesize(test, condition: true)
@@ -2054,12 +2039,9 @@ module Steep
                   condition_constr = condition_constr.update_type_env { falsy_env }
                   body_envs << truthy_env
 
-                  branch_reachable ||= next_branch_reachable && !truthy.unreachable
-                  false_branch_reachable ||= !falsy.unreachable
+                  branch_reachable ||= !truthy.unreachable
                 end
 
-                next_branch_reachable &&= false_branch_reachable
-
                 if body
                   branch_results <<
                     when_clause_constr
@@ -4490,16 +4472,27 @@ module Steep
     end
 
     def union_type_unify(*types)
-      types.inject do |type1, type2|
-        unless no_subtyping?(sub_type: type1, super_type: type2)
-          next type2
-        end
+      types = types.reject {|t| t.is_a?(AST::Types::Bot) }
 
-        unless no_subtyping?(sub_type: type2, super_type: type1)
-          next type1
-        end
+      if types.empty?
+        AST::Types::Bot.new
+      else
+        types.inject do |type1, type2|
+          next type2 if type1.is_a?(AST::Types::Any)
+          next type1 if type2.is_a?(AST::Types::Any)
 
-        union_type(type1, type2)
+          unless no_subtyping?(sub_type: type1, super_type: type2)
+            # type1 <: type2
+            next type2
+          end
+
+          unless no_subtyping?(sub_type: type2, super_type: type1)
+            # type2 <: type1
+            next type1
+          end
+
+          union_type(type1, type2)
+        end
       end
     end
 
@@ -5029,33 +5022,19 @@ module Steep
       with_new_typing(typing.parent || raise)
     end
 
-    def extract_outermost_call(node, var_name)
+    def transform_condition_node(node, var_name)
       case node.type
       when :lvasgn
         name, rhs = node.children
-        rhs, value_node = extract_outermost_call(rhs, var_name)
-        if value_node
-          [node.updated(nil, [name, rhs]), value_node]
-        else
-          [node, value_node]
-        end
+        rhs, value_node = transform_condition_node(rhs, var_name)
+        [node.updated(nil, [name, rhs]), value_node]
       when :begin
         *children, last = node.children
-        last, value_node = extract_outermost_call(last, var_name)
-        if value_node
-          [node.updated(nil, children.push(last)), value_node]
-        else
-          [node, value_node]
-        end
-      when :lvar
-        [node, nil]
+        last, value_node = transform_condition_node(last, var_name)
+        [node.updated(nil, children.push(last)), value_node]
       else
-        if value_node?(node)
-          [node, nil]
-        else
-          var_node = node.updated(:lvar, [var_name])
-          [var_node, node]
-        end
+        var_node = node.updated(:lvar, [var_name])
+        [var_node, node]
       end
     end
 
@@ -5109,5 +5088,20 @@ module Steep
         end
       end
     end
+
+    def propagate_type_env(source, dest, env)
+      source_type = env[source] or raise
+
+      if dest.type == :lvar
+        var_name = dest.children[0] #: Symbol
+        env.assign_local_variable(var_name, source_type, nil)
+      else
+        if env[dest]
+          env.replace_pure_call_type(dest, source_type)
+        else
+          env
+        end
+      end
+    end
   end
 end

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -417,6 +417,10 @@ module Steep
           end
 
           [truthy_types, falsy_types]
+        when AST::Types::Boolean
+          [[arg_type], [arg_type]]
+        when AST::Types::Top, AST::Types::Any
+          [[arg_type], [arg_type]]
         else
           types = [arg_type]
 

data/lib/steep/version.rb

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

data/sig/steep/server/interaction_worker.rbs

@@ -52,6 +52,10 @@ module Steep
 
       module LSP = LanguageServer::Protocol
 
+      @last_signature_help_line: Integer
+
+      @last_signature_help_result: LanguageServer::Protocol::Interface::SignatureHelp
+
       attr_reader service: Services::TypeCheckService
 
       def initialize: (project: Project, reader: Reader, writer: Writer, ?queue: Queue) -> void

data/sig/steep/type_construction.rbs

@@ -538,18 +538,30 @@ module Steep
     # Returns a pair of transformed node and the outer most call/non-value node if present.
     #
     # ```rb
-    # x = y = foo()   # Call `#transform_value_node` with the node and var_name `:__foo__`
+    # x = y = foo()   # Call `#transform_condition_node` with the node and var_name `:__foo__`
     #                 # => Returns [x = y = __foo__, foo()]
+    #
+    # x               # Call `#transform_condition_node` with the node and var_name `:__foo__`
+    #                 # => Returns [__foo__, x]
     # ```
     #
     # This is typically used for transforming assginment node for case condition.
     #
-    def extract_outermost_call: (Parser::AST::Node node, Symbol) -> [Parser::AST::Node, Parser::AST::Node?]
+    def transform_condition_node: (Parser::AST::Node node, Symbol) -> [Parser::AST::Node, Parser::AST::Node]
 
     def type_name: (AST::Types::t) -> RBS::TypeName?
 
     def singleton_type: (AST::Types::t) -> AST::Types::t?
 
     def instance_type: (AST::Types::t) -> AST::Types::t?
+
+    # Propagate an entry of `source` in TypeEnv to `dest`
+    #
+    # `source` is name of a local variable.
+    #
+    # If `dest` is a `lvar` node, it updates local variable entry of TypeEnv.
+    # Otherwise, it updates *pure* call of `dest` if it already exists.
+    #
+    def propagate_type_env: (Symbol source, Parser::AST::Node dest, TypeInference::TypeEnv) -> TypeInference::TypeEnv
   end
 end

metadata

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