steep 0.43.1 → 0.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7af0aaa9c4c7b0dd2bae9104603131370d976133d866e3d7760c4b2fa581e694
-  data.tar.gz: eb1421e3b07c1f06e427073bb72d55138eda935e2269874f5727eecb035a00fb
+  metadata.gz: e43c16938ef0238a9b3e44934a3e183ec663722b4c1161f9bd016dfcd2442b9b
+  data.tar.gz: 20168ebc69417b83c9eff010d44aac53ac43f47c572c8acc99d52d08ec11866d
 SHA512:
-  metadata.gz: 815776632903ca2679af4ae7e7b4a22fa4388956b56706b862f21d76bea6edbbb928d8423504a99a352db71bf7d777e1148a57fe803b582814f1f1526cc45358
-  data.tar.gz: 70839258fe699f8b246b66cf5e865cb33a9231b5d34e12b40f880bc6b3c50566fe53e0df74645785a3bf1091cbbe34ad4e216ac9d37fdcc3bb3ef32532ab5363
+  metadata.gz: 33c2bd116ea87f549ffb29fbc2382e7c000405a74280fcc4a1a8553ae52e6b7af3d5611a150c828d494fe50f37e120e58e45f286bd374bbd35958ee0c760c872
+  data.tar.gz: 0466f3f59d18bf0ba34ce522bc6a1cceed85c1f6ca4df66b6647a557bec165c64dd9d594f673833dc24a0b5a9d0eb04795bff37dc391e22cf560b566c6f08319

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,10 @@ jobs:
     strategy:
       matrix:
         container_tag:
-        - 2.6.5-bionic
-        - 2.7.0-bionic
+        - "2.6"
+        - "2.7"
+        - "3.0"
+        - "master-nightly-focal"
         task:
         - test
         - test:output

data/.gitignore

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

data/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## master
 
+## 0.46.0 (2021-08-30)
+
+This release updates Steepfile DSL syntax, introducing `stdlib_path` and `configure_code_diagnostics` syntax (methods).
+
+* `stdlib_path` allows configuring core/stdlib RBS file locations.
+* `configure_code_diagnostics` allows configuring _severity_ of each type errors.
+
+See the PRs for the explanation of these methods.
+You can try `steep init` to generate updated `Steepfile` template.
+
+* Flexible diagnostics configuration ([\#422](https://github.com/soutaro/steep/pull/422), [\#423](https://github.com/soutaro/steep/pull/423))
+* Revise Steepfile _path_ DSL ([\#421](https://github.com/soutaro/steep/pull/421))
+* Avoid to stop process by invalid jobs_count ([\#419](https://github.com/soutaro/steep/pull/419))
+* Fix `Steep::Typing::UnknownNodeError` when hover method with numblock ([\#415](https://github.com/soutaro/steep/pull/415))
+
+## 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))
+* Fix goto from block calls ([#378](https://github.com/soutaro/steep/pull/378))
+
+## 0.44.0 (2021-04-22)
+
+* Implement LSP go to definition/implementation ([#371](https://github.com/soutaro/steep/pull/371), [#375](https://github.com/soutaro/steep/pull/375))
+* Fix typing on passing optional block ([#373](https://github.com/soutaro/steep/pull/373))
+* Do not crash when completion request `context` is missing ([#370](https://github.com/soutaro/steep/pull/370))
+* Update RBS ([#376](https://github.com/soutaro/steep/pull/376))
+
 ## 0.43.1 (2021-04-01)
 
 * Fix LSP `textDocument/didSave` notification handling ([#368](https://github.com/soutaro/steep/issues/368))

data/Gemfile

@@ -9,6 +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"

data/Gemfile.lock

@@ -0,0 +1,77 @@
+PATH
+  remote: .
+  specs:
+    steep (0.46.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.2)
+    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/bin/output_test.rb

@@ -16,6 +16,8 @@ end
 
 failed_tests = []
 
+ALLOW_FAILURE = ["diagnostics-ruby-unsat"]
+
 test_dirs.each do |dir|
   puts "Running test #{dir}..."
 
@@ -30,8 +32,12 @@ test_dirs.each do |dir|
   output, status = Open3.capture2(*command, chdir: dir.to_s)
 
   unless status.success?
-    failed_tests << dir.basename
-    puts "  Failed! 🤕"
+    unless ALLOW_FAILURE.include?(dir.basename.to_s)
+      failed_tests << dir.basename
+      puts "  Failed! 🤕"
+    else
+      puts "  Failed! 🤕 (ALLOW_FAILURE)"
+    end
   else
     puts "  Succeed! 👍"
   end

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/cli.rb

@@ -70,7 +70,7 @@ module Steep
       default = physical_processor_count + modifier
       command.jobs_count = default
       opts.on("-j N", "--jobs=N", "Specify the number of type check workers (defaults: #{default})") do |count|
-        command.jobs_count = Integer(count)
+        command.jobs_count = Integer(count) if Integer(count) > 0
       end
     end
 
@@ -99,6 +99,9 @@ module Steep
           opts.on("--save-expectations[=PATH]", "Save expectations with current type check result to PATH (or steep_expectations.yml)") do |path|
             check.save_expectations_path = Pathname(path || "steep_expectations.yml")
           end
+          opts.on("--severity-level=LEVEL", /^error|warning|information|hint$/, "Specify the minimum diagnostic severity to be recognized as an error (defaults: warning): error, warning, information, or hint") do |level|
+            check.severity_level = level.to_sym
+          end
           handle_jobs_option check, opts
           handle_logging_options opts
         end.parse!(argv)
@@ -155,6 +158,9 @@ module Steep
       Drivers::Watch.new(stdout: stdout, stderr: stderr).tap do |command|
         OptionParser.new do |opts|
           opts.banner = "Usage: steep watch [options] [dirs]"
+          opts.on("--severity-level=LEVEL", /^error|warning|information|hint$/, "Specify the minimum diagnostic severity to be recognized as an error (defaults: warning): error, warning, information, or hint") do |level|
+            command.severity_level = level.to_sym
+          end
           handle_jobs_option command, opts
           handle_logging_options opts
         end.parse!(argv)

data/lib/steep/diagnostic/lsp_formatter.rb

@@ -3,13 +3,66 @@ module Steep
     class LSPFormatter
       LSP = LanguageServer::Protocol
 
+      attr_reader :config
+      attr_reader :default_severity
+
+      ERROR = :error
+      WARNING = :warning
+      INFORMATION = :information
+      HINT = :hint
+
+      def initialize(config = {}, default_severity: ERROR)
+        @config = config
+        @default_severity = default_severity
+
+        config.each do |klass, severity|
+          validate_severity(klass, severity)
+          validate_class(klass)
+        end
+        validate_severity(:default, default_severity)
+      end
+
+      def validate_class(klass)
+        unless klass < Diagnostic::Ruby::Base
+          raise "Unexpected diagnostics class `#{klass}` given"
+        end
+      end
+
+      def validate_severity(klass, severity)
+        case severity
+        when ERROR, WARNING, INFORMATION, HINT, nil
+          # ok
+        else
+          raise "Unexpected severity `#{severity}` is specified for #{klass}"
+        end
+      end
+
       def format(diagnostic)
-        LSP::Interface::Diagnostic.new(
-          message: diagnostic.full_message,
-          code: diagnostic.diagnostic_code,
-          severity: LSP::Constant::DiagnosticSeverity::ERROR,
-          range: diagnostic.location.as_lsp_range
-        ).to_hash
+        severity = severity_for(diagnostic)
+
+        if severity
+          LSP::Interface::Diagnostic.new(
+            message: diagnostic.full_message,
+            code: diagnostic.diagnostic_code,
+            severity: severity,
+            range: diagnostic.location.as_lsp_range
+          ).to_hash
+        end
+      end
+
+      def severity_for(diagnostic)
+        case config.fetch(diagnostic.class, default_severity)
+        when ERROR
+          LSP::Constant::DiagnosticSeverity::ERROR
+        when WARNING
+          LSP::Constant::DiagnosticSeverity::WARNING
+        when INFORMATION
+          LSP::Constant::DiagnosticSeverity::INFORMATION
+        when HINT
+          LSP::Constant::DiagnosticSeverity::HINT
+        when nil
+          nil
+        end
       end
     end
   end

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
 
@@ -623,6 +700,57 @@ module Steep
           "SyntaxError: #{message}"
         end
       end
+
+      ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
+        if klass < Base
+          array << klass
+        end
+      end
+
+      def self.all_error
+        @all_error ||= ALL.each.with_object({}) do |klass, hash|
+          hash[klass] = LSPFormatter::ERROR
+        end.freeze
+      end
+
+      def self.default
+        @default ||= all_error.merge(
+          {
+            ImplicitBreakValueMismatch => :warning,
+            FallbackAny => :information,
+            ElseOnExhaustiveCase => :warning,
+            UnknownConstantAssigned => :warning,
+            MethodDefinitionMissing => :information
+          }
+        ).freeze
+      end
+
+      def self.strict
+        @strict ||= all_error.merge(
+          {
+            NoMethod => nil,
+            ImplicitBreakValueMismatch => nil,
+            FallbackAny => nil,
+            ElseOnExhaustiveCase => nil,
+            UnknownConstantAssigned => nil,
+            MethodDefinitionMissing => nil
+          }
+        ).freeze
+      end
+
+      def self.lenient
+        @lenient ||= all_error.merge(
+          {
+            NoMethod => nil,
+            ImplicitBreakValueMismatch => nil,
+            FallbackAny => nil,
+            ElseOnExhaustiveCase => nil,
+            UnknownConstantAssigned => nil,
+            MethodDefinitionMissing => nil,
+            UnexpectedJump => nil
+          }
+        ).freeze
+      end
     end
   end
 end