steep 0.44.1 → 0.45.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c26760f5348c69f081ab2af0c680f6cbfb2e022c4bcd407a082c28fb818da46
-  data.tar.gz: cda7a96c3f8aca4c1ab7bed5b016b470253669c26cdb6d943b3d3430091c707f
+  metadata.gz: '080cf1692f90640baacc712908524e2daf36039ea992eb3424de7094c49f6778'
+  data.tar.gz: dd9f8837ec50e625ce9a0814fcbef03191bf484debd33034f9d00819115fef81
 SHA512:
-  metadata.gz: 1a4d1739de1974adb441c5830396ff6e79e901d55eed3e486f3b4ab5c394aa23254ccac0d8a63a5f78084e1c8cecb10a1faaddd53b8c963c8bab2b19b9aad910
-  data.tar.gz: a6b2c6c29ebca50f812062a7f7cacaaa2e6304fbbff6ff71c5a9c3ddf3d0e95341ebee5b34df090b360dc64529763eda9a6ce3cf435481a50f0a28d6fd338853
+  metadata.gz: 67d26f6197f5b4fe53195c2202cdbbf556e2496fda4498151646c6d93a8455de0b75af66c35b16f32375fc239574600e33cc5f8caf92cc8f96a659ca0588b4da
+  data.tar.gz: 718c99448377245e8e0871af93c445d037aef4dbc727185bfd658f49672c08a11e8acc3807c7cb2a55814ffd32fb87642c9b37fc9f17143d4474a2810e2e4f3e

data/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "20:00"
+  open-pull-requests-limit: 10

data/.github/workflows/ruby.yml

@@ -12,8 +12,9 @@ jobs:
     strategy:
       matrix:
         container_tag:
-        - 2.6.5-bionic
-        - 2.7.0-bionic
+        - "2.6"
+        - "2.7"
+        - "3.0"
         task:
         - test
         - test:output

data/.gitignore

@@ -1,6 +1,5 @@
 /.bundle/
 /.yardoc
-/Gemfile.lock
 /_yardoc/
 /coverage/
 /doc/

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## master
 
+## 0.45.0 (2021-08-22)
+
+* Fix error reporting on `RBS::MixinClassError` ([\#411](https://github.com/soutaro/steep/pull/411))
+* Compact error reporting for method body type mismatch ([\#414](https://github.com/soutaro/steep/pull/414))
+* Fix NoMethodError with csend/numblock ([\#412](https://github.com/soutaro/steep/pull/412))
+* LSP completion for RBS files ([\#404](https://github.com/soutaro/steep/pull/404)) 
+* Allow break without value from bot methods ([\#398](https://github.com/soutaro/steep/pull/398))
+* Type check on lvar assignments ([\#390](https://github.com/soutaro/steep/pull/390))
+* Assign different error code to break without value ([\#387](https://github.com/soutaro/steep/pull/387))
+* Support Ruby3 Keyword Arguments ([\#386](https://github.com/soutaro/steep/pull/386))
+* LSP hover for RBS files ([\#385](https://github.com/soutaro/steep/pull/385), [\#397](https://github.com/soutaro/steep/pull/397)) 
+* Fix FileLoader to skip files not matching to the given pattern ([\#382](https://github.com/soutaro/steep/pull/382))
+* Ruby3 support for numbered block parameters and end-less def ([\#381](https://github.com/soutaro/steep/pull/381))
+
 ## 0.44.1 (2021-04-23)
 
 * Disable goto declaration and goto type declaration (because they are not implemented) ([#377](https://github.com/soutaro/steep/pull/377))

data/Gemfile

@@ -9,7 +9,5 @@ gem "without_steep_types", path: "test/gems/without_steep_types"
 gem "rake"
 gem "minitest", "~> 5.0"
 gem "racc", "~> 1.4"
-gem "minitest-reporters"
 gem "minitest-hooks"
 gem "stackprof"
-gem "rbs", git: "https://github.com/ruby/rbs.git"

data/Gemfile.lock

@@ -0,0 +1,77 @@
+PATH
+  remote: .
+  specs:
+    steep (0.45.0)
+      activesupport (>= 5.1)
+      language_server-protocol (>= 3.15, < 4.0)
+      listen (~> 3.0)
+      parallel (>= 1.0.0)
+      parser (>= 3.0)
+      rainbow (>= 2.2.2, < 4.0)
+      rbs (>= 1.2.0)
+      terminal-table (>= 2, < 4)
+
+PATH
+  remote: test/gems/with_steep_types
+  specs:
+    with_steep_types (1.0.0)
+
+PATH
+  remote: test/gems/without_steep_types
+  specs:
+    without_steep_types (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    ast (2.4.2)
+    concurrent-ruby (1.1.9)
+    ffi (1.15.3)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    language_server-protocol (3.16.0.1)
+    listen (3.7.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    minitest (5.14.4)
+    minitest-hooks (1.5.0)
+      minitest (> 5.3)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    racc (1.5.2)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    rb-fsevent (0.11.0)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rbs (1.5.1)
+    stackprof (0.2.17)
+    terminal-table (3.0.1)
+      unicode-display_width (>= 1.1.1, < 3)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.0.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  minitest-hooks
+  racc (~> 1.4)
+  rake
+  stackprof
+  steep!
+  with_steep_types!
+  without_steep_types!
+
+BUNDLED WITH
+   2.2.22

data/lib/steep.rb

@@ -1,7 +1,7 @@
 require "steep/version"
 
 require "pathname"
-require "parser/ruby27"
+require "parser/ruby30"
 require "active_support/core_ext/object/try"
 require "active_support/core_ext/string/inflections"
 require "logger"
@@ -21,6 +21,7 @@ require "terminal-table"
 
 require "rbs"
 
+require "steep/equatable"
 require "steep/method_name"
 require "steep/ast/types/helper"
 require "steep/ast/types/any"
@@ -77,6 +78,7 @@ require "steep/type_inference/context"
 require "steep/type_inference/context_array"
 require "steep/type_inference/send_args"
 require "steep/type_inference/block_params"
+require "steep/type_inference/method_params"
 require "steep/type_inference/constant_env"
 require "steep/type_inference/type_env"
 require "steep/type_inference/local_variable_type_env"

data/lib/steep/ast/builtin.rb

@@ -10,8 +10,14 @@ module Steep
           @arity = arity
         end
 
-        def instance_type(*args)
+        def instance_type(*args, fill_untyped: false)
+          if fill_untyped
+            (arity - args.size).times do
+              args << Builtin.any_type
+            end
+          end
           arity == args.size or raise "Mulformed instance type: name=#{module_name}, args=#{args}"
+
           Types::Name::Instance.new(name: module_name, args: args)
         end
 

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

@@ -194,7 +194,7 @@ module Steep
         end
 
         def params(type)
-          Interface::Function::Params.new(
+          Interface::Function::Params.build(
             required: type.required_positionals.map {|param| type(param.type) },
             optional: type.optional_positionals.map {|param| type(param.type) },
             rest: type.rest_positionals&.yield_self {|param| type(param.type) },
@@ -621,12 +621,7 @@ module Steep
                       Interface::MethodType.new(
                         type_params: [],
                         type: Interface::Function.new(
-                          params: Interface::Function::Params.new(required: [AST::Types::Literal.new(value: index)],
-                                                                  optional: [],
-                                                                  rest: nil,
-                                                                  required_keywords: {},
-                                                                  optional_keywords: {},
-                                                                  rest_keywords: nil),
+                          params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
                           return_type: elem_type,
                           location: nil
                         ),
@@ -643,12 +638,7 @@ module Steep
                       Interface::MethodType.new(
                         type_params: [],
                         type: Interface::Function.new(
-                          params: Interface::Function::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
-                                                                  optional: [],
-                                                                  rest: nil,
-                                                                  required_keywords: {},
-                                                                  optional_keywords: {},
-                                                                  rest_keywords: nil),
+                          params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index), elem_type]),
                           return_type: elem_type,
                           location: nil
                         ),
@@ -712,12 +702,14 @@ module Steep
                       Interface::MethodType.new(
                         type_params: [],
                         type: Interface::Function.new(
-                          params: Interface::Function::Params.new(required: [key_type],
-                                                                  optional: [],
-                                                                  rest: nil,
-                                                                  required_keywords: {},
-                                                                  optional_keywords: {},
-                                                                  rest_keywords: nil),
+                          params: Interface::Function::Params.build(
+                            required: [key_type],
+                            optional: [],
+                            rest: nil,
+                            required_keywords: {},
+                            optional_keywords: {},
+                            rest_keywords: nil
+                          ),
                           return_type: value_type,
                           location: nil
                         ),
@@ -735,12 +727,14 @@ module Steep
                       Interface::MethodType.new(
                         type_params: [],
                         type: Interface::Function.new(
-                          params: Interface::Function::Params.new(required: [key_type, value_type],
-                                                                  optional: [],
-                                                                  rest: nil,
-                                                                  required_keywords: {},
-                                                                  optional_keywords: {},
-                                                                  rest_keywords: nil),
+                          params: Interface::Function::Params.build(
+                            required: [key_type, value_type],
+                            optional: [],
+                            rest: nil,
+                            required_keywords: {},
+                            optional_keywords: {},
+                            rest_keywords: nil
+                          ),
                           return_type: value_type,
                           location: nil),
                         block: nil,

data/lib/steep/diagnostic/ruby.rb

@@ -71,46 +71,104 @@ module Steep
         end
       end
 
-      class IncompatibleArguments < Base
+      class UnexpectedPositionalArgument < Base
         attr_reader :node
+        attr_reader :method_type
         attr_reader :method_name
-        attr_reader :receiver_type
-        attr_reader :method_types
 
-        def initialize(node:, method_name:, receiver_type:, method_types:)
-          location = case node.type
-                     when :send
-                       node.loc.selector
-                     when :block
-                       node.children[0].yield_self do |node|
-                         node.loc.selector
-                       end
-                     when :super
-                       node.loc.expression
-                     else
-                       Steep.logger.error { "Unexpected node given: #{node.type} (IncompatibleArguments#initialize)"}
-                       node.loc.expression
-                     end
-          super(node: node, location: location)
-          @receiver_type = receiver_type
-          @method_types = method_types
+        def initialize(node:, method_name:, method_type:)
+          super(node: node)
           @method_name = method_name
+          @method_type = method_type
         end
 
         def header_line
-          "Cannot find method `#{method_name}` of type `#{receiver_type}` with compatible arity"
+          "Unexpected positional argument"
         end
+      end
 
-        def detail_lines
-          StringIO.new.tap do |io|
-            io.puts "Method types:"
-            first_type, *rest_types = method_types
-            defn = "  def #{method_name}"
-            io.puts "#{defn}: #{first_type}"
-            rest_types.each do |method_type|
-              io.puts "#{" " * defn.size}| #{method_type}"
-            end
-          end.string.chomp
+      class InsufficientPositionalArguments < Base
+        attr_reader :node
+        attr_reader :method_name
+        attr_reader :method_type
+
+        def initialize(node:, method_name:, method_type:)
+          send = case node.type
+                 when :send, :csend
+                   node
+                 when :block, :numblock
+                   node.children[0]
+                 end
+
+          loc = if send
+                  send.loc.selector.with(end_pos: send.loc.expression.end_pos)
+                else
+                  node.loc.expression
+                end
+
+          super(node: node, location: loc)
+          @method_name = method_name
+          @method_type = method_type
+        end
+
+        def header_line
+          "More positional arguments are required"
+        end
+      end
+
+      class UnexpectedKeywordArgument < Base
+        attr_reader :node
+        attr_reader :method_name
+        attr_reader :method_type
+
+        def initialize(node:, method_name:, method_type:)
+          loc = case node.type
+                when :pair
+                  node.children[0].location.expression
+                when :kwsplat
+                  node.location.expression
+                else
+                  raise
+                end
+          super(node: node, location: loc)
+          @method_name = method_name
+          @method_type = method_type
+        end
+
+        def header_line
+          "Unexpected keyword argument"
+        end
+      end
+
+      class InsufficientKeywordArguments < Base
+        attr_reader :node
+        attr_reader :method_name
+        attr_reader :method_type
+        attr_reader :missing_keywords
+
+        def initialize(node:, method_name:, method_type:, missing_keywords:)
+          send = case node.type
+                 when :send, :csend
+                   node
+                 when :block, :numblock
+                   node.children[0]
+                 end
+
+          loc = if send
+                  send.loc.selector.with(end_pos: send.loc.expression.end_pos)
+                else
+                  node.loc.expression
+                end
+
+          super(node: node, location: loc)
+
+          @method_name = method_name
+          @method_type = method_type
+          @missing_keywords = missing_keywords
+        end
+
+        def header_line
+          "More keyword arguments are required: #{missing_keywords.join(", ")}"
         end
       end
 
@@ -292,6 +350,23 @@ module Steep
         end
       end
 
+      class ImplicitBreakValueMismatch < Base
+        attr_reader :jump_type
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, jump_type:, result:)
+          super(node: node)
+          @jump_type = jump_type
+          @result = result
+        end
+
+        def header_line
+          "Breaking without a value may result an error because a value of type `#{jump_type}` is expected"
+        end
+      end
+
       class UnexpectedJump < Base
         def header_line
           "Cannot jump from here"
@@ -323,6 +398,36 @@ module Steep
         end
       end
 
+      class MethodParameterMismatch < Base
+        attr_reader :method_param
+        attr_reader :method_type
+
+        def initialize(method_param:, method_type:)
+          super(node: method_param.node)
+          @method_param = method_param
+          @method_type = method_type
+        end
+
+        def header_line
+          "The method parameter is incompatible with the declaration `#{method_type}`"
+        end
+      end
+
+      class DifferentMethodParameterKind < Base
+        attr_reader :method_param
+        attr_reader :method_type
+
+        def initialize(method_param:, method_type:)
+          super(node: method_param.node)
+          @method_param = method_param
+          @method_type = method_type
+        end
+
+        def header_line
+          "The method parameter has different kind from the declaration `#{method_type}`"
+        end
+      end
+
       class IncompatibleMethodTypeAnnotation < Base
         attr_reader :interface_method
         attr_reader :annotation_method
@@ -366,7 +471,7 @@ module Steep
         include ResultPrinter
 
         def initialize(node:, expected:, actual:, result:)
-          super(node: node)
+          super(node: node, location: node.loc.name)
           @expected = expected
           @actual = actual
           @result = result
@@ -552,34 +657,6 @@ module Steep
         end
       end
 
-      class UnexpectedKeyword < Base
-        attr_reader :unexpected_keywords
-
-        def initialize(node:, unexpected_keywords:)
-          super(node: node)
-          @unexpected_keywords = unexpected_keywords
-        end
-
-        def header_line
-          keywords = unexpected_keywords.sort.map {|x| "`#{x}`" }
-          "Cannot specify unexpected keyword arguments: #{keywords.join(", ")}"
-        end
-      end
-
-      class MissingKeyword < Base
-        attr_reader :missing_keywords
-
-        def initialize(node:, missing_keywords:)
-          super(node: node)
-          @missing_keywords = missing_keywords
-        end
-
-        def header_line
-          keywords = missing_keywords.sort.map {|x| "`#{x}`" }
-          "Cannot omit required keywords: #{keywords.join(", ")}"
-        end
-      end
-
       class UnsupportedSyntax < Base
         attr_reader :message