steep 1.5.0.pre.6 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d00242c259b7c8d2a4a0f7022874ac5bb5f08491ab3edade6165ff1a9fbe89a7
-  data.tar.gz: e02d896359c4eb88c730601320bb9137342c19b9ad1956d4ac417ffa5926d74a
+  metadata.gz: 77aea7baf36285cf4a5b0941e63cc8f5f95d52132d3a5d4933a396a79b949721
+  data.tar.gz: 2506370595dde6633abbab74b1e370d435579415a154b4a82b4da3bb1b065627
 SHA512:
-  metadata.gz: 5be83d84d984d215342c030e9ea590c419a1e12963361266f4bc57e2b2ceec110a3f08313754b2f46a274fc8b0d2acca497c71f2eff24c3fd4505cb1ff2ac5a7
-  data.tar.gz: 7a30b064aa7ec6e27e3811e93b1ddf7ff4824cdeb5dfe70075f34311f7e22016bf4f3a2b107307a5247c54532451a25155fc2ba277842fec85f71aa23fdaced1
+  metadata.gz: 6f3190f0ca65a931f9c88d99cbd67836478d754439b5630b1b68f89e9fa6d84a84cc8bde32335d4bdb38b3f13aefaeaf93a75b53722a0b6841eab27e9b689ed8
+  data.tar.gz: 94576f1eedcb8c46ca8228e84e4100e860c0e3ed2a28dc209afa80abdeeed188118f1589dcb15d0a8edb0cd8c751f611035a15b613d284113c8cbebcce42dc6e

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## master
 
+## 1.5.0 (2023-07-13)
+
+### Type checker core
+
+* Fix for the case `untyped` is the proc type hint ([#868](https://github.com/soutaro/steep/pull/868))
+* Type case with type variable ([#869](https://github.com/soutaro/steep/pull/869))
+* Filx `nil?` unreachability detection ([#867](https://github.com/soutaro/steep/pull/867))
+
+### Commandline tool
+
+* Update `#configure_code_diagnostics` type ([#873](https://github.com/soutaro/steep/pull/873))
+* Update diagnostics templates ([#871](https://github.com/soutaro/steep/pull/871))
+* Removed "set" from "libray" in init.rb and README ([#870](https://github.com/soutaro/steep/pull/870))
+
+### Language server
+
+* Use RBS::Buffer method to calculate position ([#872](https://github.com/soutaro/steep/pull/872))
+
 ## 1.5.0.pre.6 (2023-07-11)
 
 ### Type checker core

data/Gemfile.lock

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

data/README.md

@@ -30,7 +30,7 @@ target :app do
   check "lib"
   signature "sig"
 
-  library "set", "pathname"
+  library "pathname"
 end
 ```
 

data/lib/steep/diagnostic/ruby.rb

@@ -992,20 +992,57 @@ module Steep
       def self.default
         @default ||= _ = all_error.merge(
           {
-            ImplicitBreakValueMismatch => :warning,
-            FallbackAny => :information,
-            UnreachableValueBranch => :warning,
-            UnreachableBranch => :information,
+            ArgumentTypeMismatch => :error,
+            BlockBodyTypeMismatch => :hint,
+            BlockTypeMismatch => :hint,
+            BreakTypeMismatch => :hint,
+            DifferentMethodParameterKind => :hint,
+            FallbackAny => :hint,
+            FalseAssertion => :hint,
+            ImplicitBreakValueMismatch => :hint,
+            IncompatibleAnnotation => :hint,
+            IncompatibleArgumentForwarding => :warning,
+            IncompatibleAssignment => :hint,
+            IncompatibleMethodTypeAnnotation => :hint,
+            IncompatibleTypeCase => :hint,
+            InsufficientKeywordArguments => :error,
+            InsufficientPositionalArguments => :error,
+            InsufficientTypeArgument => :hint,
+            MethodArityMismatch => :error,
+            MethodBodyTypeMismatch => :error,
+            MethodDefinitionMissing => nil,
+            MethodParameterMismatch => :error,
+            MethodReturnTypeAnnotationMismatch => :hint,
+            MultipleAssignmentConversionError => :hint,
+            NoMethod => :error,
+            ProcHintIgnored => :hint,
+            ProcTypeExpected => :hint,
+            RBSError => :information,
+            RequiredBlockMissing => :error,
+            ReturnTypeMismatch => :error,
+            SetterBodyTypeMismatch => :information,
+            SetterReturnTypeMismatch => :information,
+            SyntaxError => :hint,
+            TypeArgumentMismatchError => :hint,
+            UnexpectedBlockGiven => :warning,
+            UnexpectedDynamicMethod => :hint,
+            UnexpectedError => :hint,
+            UnexpectedJump => :hint,
+            UnexpectedJumpValue => :hint,
+            UnexpectedKeywordArgument => :error,
+            UnexpectedPositionalArgument => :error,
+            UnexpectedSplat => :hint,
+            UnexpectedSuper => :information,
+            UnexpectedTypeArgument => :hint,
+            UnexpectedYield => :warning,
             UnknownConstant => :warning,
-            MethodDefinitionMissing => :information,
-            FalseAssertion => :information,
-            UnexpectedTypeArgument => :information,
-            InsufficientTypeArgument => :information,
-            UnexpectedTypeArgument => :information,
-            UnsupportedSyntax => nil,
-            ProcHintIgnored => :information,
-            SetterBodyTypeMismatch => nil,
-            SetterReturnTypeMismatch => nil
+            UnknownGlobalVariable => :warning,
+            UnknownInstanceVariable => :information,
+            UnreachableBranch => :hint,
+            UnreachableValueBranch => :hint,
+            UnresolvedOverloading => :error,
+            UnsatisfiableConstraint => :hint,
+            UnsupportedSyntax => :hint,
           }
         ).freeze
       end
@@ -1013,17 +1050,57 @@ module Steep
       def self.strict
         @strict ||= _ = all_error.merge(
           {
-            NoMethod => nil,
-            ImplicitBreakValueMismatch => nil,
-            FallbackAny => nil,
-            UnreachableValueBranch => nil,
-            UnreachableBranch => nil,
-            UnknownConstant => nil,
-            MethodDefinitionMissing => nil,
-            UnsupportedSyntax => nil,
-            ProcHintIgnored => :warning,
+            ArgumentTypeMismatch => :error,
+            BlockBodyTypeMismatch => :error,
+            BlockTypeMismatch => :error,
+            BreakTypeMismatch => :error,
+            DifferentMethodParameterKind => :error,
+            FallbackAny => :warning,
+            FalseAssertion => :error,
+            ImplicitBreakValueMismatch => :information,
+            IncompatibleAnnotation => :error,
+            IncompatibleArgumentForwarding => :error,
+            IncompatibleAssignment => :error,
+            IncompatibleMethodTypeAnnotation => :error,
+            IncompatibleTypeCase => :error,
+            InsufficientKeywordArguments => :error,
+            InsufficientPositionalArguments => :error,
+            InsufficientTypeArgument => :error,
+            MethodArityMismatch => :error,
+            MethodBodyTypeMismatch => :error,
+            MethodDefinitionMissing => :hint,
+            MethodParameterMismatch => :error,
+            MethodReturnTypeAnnotationMismatch => :error,
+            MultipleAssignmentConversionError => :error,
+            NoMethod => :error,
+            ProcHintIgnored => :information,
+            ProcTypeExpected => :error,
+            RBSError => :error,
+            RequiredBlockMissing => :error,
+            ReturnTypeMismatch => :error,
             SetterBodyTypeMismatch => :error,
-            SetterReturnTypeMismatch => :error
+            SetterReturnTypeMismatch => :error,
+            SyntaxError => :hint,
+            TypeArgumentMismatchError => :error,
+            UnexpectedBlockGiven => :error,
+            UnexpectedDynamicMethod => :information,
+            UnexpectedError => :information,
+            UnexpectedJump => :error,
+            UnexpectedJumpValue => :error,
+            UnexpectedKeywordArgument => :error,
+            UnexpectedPositionalArgument => :error,
+            UnexpectedSplat => :warning,
+            UnexpectedSuper => :error,
+            UnexpectedTypeArgument => :error,
+            UnexpectedYield => :error,
+            UnknownConstant => :error,
+            UnknownGlobalVariable => :error,
+            UnknownInstanceVariable => :error,
+            UnreachableBranch => :information,
+            UnreachableValueBranch => :warning,
+            UnresolvedOverloading => :error,
+            UnsatisfiableConstraint => :error,
+            UnsupportedSyntax => :information,
           }
         ).freeze
       end
@@ -1031,19 +1108,57 @@ module Steep
       def self.lenient
         @lenient ||= _ = all_error.merge(
           {
-            NoMethod => nil,
-            ImplicitBreakValueMismatch => nil,
+            ArgumentTypeMismatch => :information,
+            BlockBodyTypeMismatch => :hint,
+            BlockTypeMismatch => :hint,
+            BreakTypeMismatch => :hint,
+            DifferentMethodParameterKind => nil,
             FallbackAny => nil,
-            UnreachableValueBranch => nil,
-            UnreachableBranch => nil,
-            UnknownConstant => nil,
+            FalseAssertion => nil,
+            ImplicitBreakValueMismatch => nil,
+            IncompatibleAnnotation => nil,
+            IncompatibleArgumentForwarding => :information,
+            IncompatibleAssignment => :hint,
+            IncompatibleMethodTypeAnnotation => nil,
+            IncompatibleTypeCase => nil,
+            InsufficientKeywordArguments => :information,
+            InsufficientPositionalArguments => :information,
+            InsufficientTypeArgument => nil,
+            MethodArityMismatch => :information,
+            MethodBodyTypeMismatch => :warning,
             MethodDefinitionMissing => nil,
-            UnexpectedJump => nil,
-            FalseAssertion => :hint,
-            UnsupportedSyntax => nil,
-            ProcHintIgnored => :hint,
+            MethodParameterMismatch => :warning,
+            MethodReturnTypeAnnotationMismatch => nil,
+            MultipleAssignmentConversionError => nil,
+            NoMethod => :information,
+            ProcHintIgnored => nil,
+            ProcTypeExpected => nil,
+            RBSError => :information,
+            RequiredBlockMissing => :hint,
+            ReturnTypeMismatch => :warning,
             SetterBodyTypeMismatch => nil,
-            SetterReturnTypeMismatch => nil
+            SetterReturnTypeMismatch => nil,
+            SyntaxError => :hint,
+            TypeArgumentMismatchError => nil,
+            UnexpectedBlockGiven => :hint,
+            UnexpectedDynamicMethod => nil,
+            UnexpectedError => :hint,
+            UnexpectedJump => nil,
+            UnexpectedJumpValue => nil,
+            UnexpectedKeywordArgument => :information,
+            UnexpectedPositionalArgument => :information,
+            UnexpectedSplat => nil,
+            UnexpectedSuper => nil,
+            UnexpectedTypeArgument => nil,
+            UnexpectedYield => :information,
+            UnknownConstant => :hint,
+            UnknownGlobalVariable => :hint,
+            UnknownInstanceVariable => :hint,
+            UnreachableBranch => :hint,
+            UnreachableValueBranch => :hint,
+            UnresolvedOverloading => :information,
+            UnsatisfiableConstraint => :hint,
+            UnsupportedSyntax => :hint,
           }
         ).freeze
       end

data/lib/steep/drivers/init.rb

@@ -18,9 +18,10 @@ module Steep
       #   check "app/models/**/*.rb"        # Glob
       #   # ignore "lib/templates/*.rb"
       #
-      #   # library "pathname", "set"       # Standard libraries
+      #   # library "pathname"              # Standard libraries
       #   # library "strong_json"           # Gems
       #
+      #   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
       #   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
       #   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
       #   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
@@ -34,7 +35,7 @@ module Steep
       #
       #   check "test"
       #
-      #   # library "pathname", "set"       # Standard libraries
+      #   # library "pathname"              # Standard libraries
       # end
       EOF
 

data/lib/steep/project/dsl.rb

@@ -143,27 +143,6 @@ module Steep
           @repo_paths.push(*paths.map {|s| Pathname(s) })
         end
 
-        # Configure the code diagnostics printing setup.
-        #
-        # Yields a hash, and the update the hash in the block.
-        #
-        # ```rb
-        # D = Steep::Diagnostic
-        #
-        # configure_code_diagnostics do |hash|
-        #   # Assign one of :error, :warning, :information, :hint or :nil to error classes.
-        #   hash[D::Ruby::UnexpectedPositionalArgument] = :error
-        # end
-        # ```
-        #
-        # Passing a hash is also allowed.
-        #
-        # ```rb
-        # D = Steep::Diagnostic
-        #
-        # configure_code_diagnostics(D::Ruby.lenient)
-        # ```
-        #
         def configure_code_diagnostics(hash = nil)
           if hash
             code_diagnostics_config.merge!(hash)

data/lib/steep/source.rb

@@ -330,13 +330,12 @@ module Steep
     def find_heredoc_nodes(line, column, position)
       each_heredoc_node() do |nodes, location|
         node = nodes[0]
+        loc = location.heredoc_body #: Parser::Source::Range
 
-        range = location.heredoc_body&.yield_self do |r|
-          r.begin_pos..r.end_pos
-        end
-
-        if range && (range === position)
-          return nodes
+        if range = loc.to_range
+          if range.begin <= position && position <= range.end
+            return nodes
+          end
         end
       end
 
@@ -344,12 +343,10 @@ module Steep
     end
 
     def find_nodes_loc(node, position, parents)
-      range = node.location.expression&.yield_self do |r|
-        r.begin_pos..r.end_pos
-      end
+      range = node.location.expression&.to_range
 
       if range
-        if range === position
+        if range.begin <= position && position <= range.end
           parents.unshift node
 
           Source.each_child_node(node) do |child|
@@ -366,9 +363,7 @@ module Steep
     def find_nodes(line:, column:)
       return [] unless node
 
-      position = (line-1).times.sum do |i|
-        node.location.expression.source_buffer.source_line(i+1).size + 1
-      end + column
+      position = buffer.loc_to_pos([line, column])
 
       if heredoc_nodes = find_heredoc_nodes(line, column, position)
         Source.each_child_node(heredoc_nodes[0]) do |child|

data/lib/steep/type_construction.rb

@@ -3103,27 +3103,29 @@ module Steep
 
         type_hint = deep_expand_alias(type_hint) || type_hint
 
-        procs = flatten_union(type_hint).select do |type|
-          check_relation(sub_type: type, super_type: AST::Builtin::Proc.instance_type).success? &&
-            !type.is_a?(AST::Types::Any)
-        end
+        unless type_hint.is_a?(AST::Types::Any)
+          procs = flatten_union(type_hint).select do |type|
+            check_relation(sub_type: type, super_type: AST::Builtin::Proc.instance_type).success? &&
+              !type.is_a?(AST::Types::Any)
+          end
 
-        proc_instances, proc_types = procs.partition {|type| AST::Builtin::Proc.instance_type?(type) }
+          proc_instances, proc_types = procs.partition {|type| AST::Builtin::Proc.instance_type?(type) }
 
-        case
-        when !proc_instances.empty? && proc_types.empty?
-          # `::Proc` is given as a hint
-        when proc_types.size == 1
-          # Proc type is given as a hint
-          hint_proc = proc_types[0]  #: AST::Types::Proc
-          params_hint = hint_proc.type.params
-          return_hint = hint_proc.type.return_type
-          block_hint = hint_proc.block
-          self_hint = hint_proc.self_type
-        else
-          typing.add_error(
-            Diagnostic::Ruby::ProcHintIgnored.new(hint_type: original_hint, node: node)
-          )
+          case
+          when !proc_instances.empty? && proc_types.empty?
+            # `::Proc` is given as a hint
+          when proc_types.size == 1
+            # Proc type is given as a hint
+            hint_proc = proc_types[0]  #: AST::Types::Proc
+            params_hint = hint_proc.type.params
+            return_hint = hint_proc.type.return_type
+            block_hint = hint_proc.block
+            self_hint = hint_proc.self_type
+          else
+            typing.add_error(
+              Diagnostic::Ruby::ProcHintIgnored.new(hint_type: original_hint, node: node)
+            )
+          end
         end
       end
 

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -280,20 +280,22 @@ module Steep
         when AST::Types::Logic::ReceiverIsNil
           if receiver && arguments.size.zero?
             receiver_type = typing.type_of(node: receiver)
-            truthy_receiver, falsy_receiver = factory.partition_union(receiver_type)
+            unwrap = factory.unwrap_optional(receiver_type)
+            truthy_receiver = AST::Builtin.nil_type
+            falsy_receiver = unwrap || receiver_type
 
             truthy_env, falsy_env = refine_node_type(
               env: env,
               node: receiver,
-              truthy_type: falsy_receiver || BOT,
-              falsy_type: truthy_receiver || BOT
+              truthy_type: truthy_receiver,
+              falsy_type: falsy_receiver
             )
 
             truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
-            truthy_result.unreachable! unless truthy_receiver
+            truthy_result.unreachable! if unwrap == receiver_type
 
             falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
-            falsy_result.unreachable! unless falsy_receiver
+            falsy_result.unreachable! unless unwrap
 
             [truthy_result, falsy_result]
           end
@@ -500,7 +502,7 @@ module Steep
             type_case_select0(ty, klass)
           end
 
-        when AST::Types::Any, AST::Types::Top
+        when AST::Types::Any, AST::Types::Top, AST::Types::Var
           [
             [instance_type],
             [type]

data/lib/steep/version.rb

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

data/sig/steep/ast/types/factory.rbs

@@ -77,13 +77,12 @@ module Steep
         # Returns a type that doesn't have `nil` in the union component
         #
         # * Returns `nil` if given type is `nil`
-        # * **Doesn't expand type alias automatically**
+        # * Expand (unfold) the type aliases automatically
         #
         # ```ruby
         # unwrap_optional(`String?`)                               # => `String`
         # unwrap_optional(`String | Integer | false | nil`)        # => `String | Integer | false`
         # unwrap_optional(`nil`)                                   # => nil
-        # unwrap_optional(`boolish`)                               # => `boolish`
         # ```
         #
         def unwrap_optional: (Types::t) -> Types::t?

data/sig/steep/diagnostic/ruby.rbs

@@ -623,7 +623,7 @@ module Steep
       end
 
       # RBS embedded in the Ruby code has validation error
-      # 
+      #
       class RBSError < Base
         attr_reader error: Signature::Base
 
@@ -662,21 +662,35 @@ module Steep
 
       ALL: Array[singleton(Base)]
 
-      type template = Hash[singleton(Base), LSPFormatter::severity]
+      type template = Hash[singleton(Base), LSPFormatter::severity?]
 
       self.@all_error: template?
+      self.@default: template?
+      self.@strict: template?
+      self.@lenient: template?
+      self.@silent: template?
+
+      # This template reports everything as an error
+      #
       def self.all_error: () -> template
 
-      self.@default: template?
+      # This template detects inconsistencies between RBS and Ruby code APIs
+      #
       def self.default: () -> template
 
-      self.@strict: template?
+      # This template helps you keeping your codebase (almost) type-safe
+      #
+      # You can start with this template to review the problems reported on the project,
+      # and you can ignore some kind of errors.
+      #
       def self.strict: () -> template
 
-      self.@lenient: template?
+      # This template detects inconsistent definition in Ruby code with respect to your RBS definition
+      #
       def self.lenient: () -> template
 
-      self.@silent: template?
+      # This template reports nothing
+      #
       def self.silent: () -> template
     end
   end

data/sig/steep/project/dsl.rbs

@@ -1,3 +1,5 @@
+use Steep::Diagnostic::Ruby::template
+
 module Steep
   class Project
     class DSL
@@ -71,10 +73,13 @@ module Steep
         # D = Steep::Diagnostic
         #
         # configure_code_diagnostics(D::Ruby.lenient)
+        # configure_code_diagnostics(D::Ruby.strict) do |config|
+        #   config[D::Ruby::NoMethod] = nil
+        # end
         # ```
         #
-        def configure_code_diagnostics: (Hash[untyped, untyped] hash) -> void
-                                      | () { (Hash[untyped, untyped]) -> void } -> void
+        def configure_code_diagnostics: (template hash) ?{ (template) -> void }-> void
+                                      | () { (template) -> void }-> void
 
         def collection_config: (Pathname path) -> void
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.5.0.pre.6
+  version: 1.5.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-11 00:00:00.000000000 Z
+date: 2023-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -782,9 +782,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.10
 signing_key: