steep 0.36.0 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5203340eb3b3534da5f1071cc497bbe7a481553e909088277c83dbfe5e5c0bbc
-  data.tar.gz: 11863c0ea9b692de6fba552ec01645525240c025c598235f9b3bf88e35571ed5
+  metadata.gz: 7fe01659cf0cfc1c7063fede02ec238b5772bb6c6fdf44cf501ca555c719c47c
+  data.tar.gz: d74ebe84a911514eef46cd92a14dfedc0b90e491aa9bf284f82325a9c4a9c2b4
 SHA512:
-  metadata.gz: 9897fecb7ca5b60da9eeb236e5f06af1a9b2fa2a2df2bd87d07f7a496f0f05b988b30db2e294797304c6d7f0e8fe478cdc1d41049cbaf2e56c45108444b2c721
-  data.tar.gz: fa2dca2cd37d74e39878ab3da7a5453a714f50e921fcd1c0e75054bf083a11003cb5799f4f92531a10bce6074dce3cce88c90daeb214b9fb45d7f5612e294fb3
+  metadata.gz: cd2459353ab367c913f0308b1cb0dd95d297cce18ea3bb4ff537612edc0b8adc2ef4530d4bf8203c6c777fe57b8bccfbf8a8714ebc0ede67400a030e6ea1348f
+  data.tar.gz: b3ee38f5e340f05420783dc3f8a31ac662f475ec7bcef82222e5f07360faac1235249fa903c721a1d322b7999034b74e7f812fa47c3d3dec8a9f5763fa2693fb

data/.github/workflows/ruby.yml

@@ -16,7 +16,7 @@ jobs:
         - 2.7.0-bionic
         task:
         - test
-        - smoke
+        - test:output
         - build
     container:
       image: rubylang/ruby:${{ matrix.container_tag }}

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## master
 
+## 0.41.0 (2021-02-07)
+
+* Add `--with-expectations` and `--save-expectations` option ([#303](https://github.com/soutaro/steep/pull/303))
+
+## 0.40.0 (2021-01-31)
+
+* Report progress with dots ([#287](https://github.com/soutaro/steep/pull/287))
+* Diagnostics message improvements ([#297](https://github.com/soutaro/steep/pull/297), [#301](https://github.com/soutaro/steep/pull/301))
+* Fix error on implicit `to_proc` syntax when `untyped` is yielded ([#291](https://github.com/soutaro/steep/pull/291))
+
+## 0.39.0 (2020-12-25)
+
+* Update RBS to 1.0.0 ([#282](https://github.com/soutaro/steep/pull/282))
+* Better `&&` and `||` typing ([#276](https://github.com/soutaro/steep/pull/276))
+* Type case based on literals ([#277](https://github.com/soutaro/steep/pull/277))
+* Type case improvements ([#279](https://github.com/soutaro/steep/pull/279), [#283](https://github.com/soutaro/steep/pull/283))
+* Improvements on untyped classes/modules, unsupported syntax error handling, and argument types in untyped methods ([#280](https://github.com/soutaro/steep/pull/280))
+* Fix `bot` and `top` type format ([#278](https://github.com/soutaro/steep/pull/278))
+* Colorfull error messages ([#273](https://github.com/soutaro/steep/pull/273))
+
+## 0.38.0 (2020-12-10)
+
+* Improve `break`/`next` typing ([#271](https://github.com/soutaro/steep/pull/271))
+* Add LSP `workspace/symbol` feature ([#267](https://github.com/soutaro/steep/pull/267))
+
+## 0.37.0 (2020-12-06)
+
+* Update to RBS 0.20.0 with _singleton attribute_ syntax and _proc types with blocks_. ([#264](https://github.com/soutaro/steep/pull/264))
+
 ## 0.36.0 (2020-11-16)
 
 * Flow-sensitive typing improvements with `||` and `&&` ([#260](https://github.com/soutaro/steep/pull/260))

data/Rakefile

@@ -9,6 +9,9 @@ end
 
 task :default => :test
 
-task :smoke do
-  sh "bundle", "exec", "bin/smoke_runner.rb", *Dir.glob("smoke/*")
+namespace :test do
+  desc "Run output test"
+  task :output do
+    sh "ruby", "bin/output_test.rb"
+  end
 end

data/bin/output_rebaseline.rb

@@ -0,0 +1,34 @@
+require "pathname"
+require "yaml"
+require "open3"
+require "tempfile"
+
+if ARGV.empty?
+  test_dirs = (Pathname(__dir__) + "../smoke").children
+else
+  test_dirs = ARGV.map {|p| Pathname.pwd + p }
+end
+
+failed_tests = []
+
+test_dirs.each do |dir|
+  puts "Rebaselining #{dir}..."
+
+  command = %w(steep check --save-expectations=test_expectations.yml)
+  puts "  command: #{command.join(" ")}"
+
+  output, status = Open3.capture2(*command, chdir: dir.to_s)
+
+  unless status.success?
+    puts "Error!!! 👺"
+    failed_tests << dir.basename
+  end
+end
+
+if failed_tests.empty?
+  puts "Successfully updated output expectations! 🤡"
+else
+  puts "Failed to update the following tests! 💀"
+  puts "  #{failed_tests.join(", ")}"
+  exit 1
+end

data/bin/output_test.rb

@@ -0,0 +1,53 @@
+require "pathname"
+require "yaml"
+require "open3"
+require "tempfile"
+require "optparse"
+
+OptionParser.new do |opts|
+  opts.on("--verbose", "-v") { @verbose = true }
+end.parse!(ARGV)
+
+if ARGV.empty?
+  test_dirs = (Pathname(__dir__) + "../smoke").children
+else
+  test_dirs = ARGV.map {|p| Pathname.pwd + p }
+end
+
+failed_tests = []
+
+test_dirs.each do |dir|
+  puts "Running test #{dir}..."
+
+  unless (dir + "test_expectations.yml").file?
+    puts "Skipped ⛹️‍♀️"
+    next
+  end
+
+  command = %w(steep check --with-expectations=test_expectations.yml)
+  puts "  command: #{command.join(" ")}"
+
+  output, status = Open3.capture2(*command, chdir: dir.to_s)
+
+  unless status.success?
+    failed_tests << dir.basename
+    puts "  Failed! 🤕"
+  else
+    puts "  Succeed! 👍"
+  end
+
+  if @verbose
+    puts "  Raw output:"
+    output.split(/\n/).each do |line|
+      puts "  > #{line.chomp}"
+    end
+  end
+end
+
+if failed_tests.empty?
+  puts "All tests ok! 👏"
+else
+  puts "Errors detected! 🤮"
+  puts "  #{failed_tests.join(", ")}"
+  exit 1
+end

data/lib/steep.rb

@@ -4,6 +4,7 @@ require "pathname"
 require "parser/ruby27"
 require "ast_utils"
 require "active_support/core_ext/object/try"
+require "active_support/core_ext/string/inflections"
 require "logger"
 require "active_support/tagged_logging"
 require "rainbow"
@@ -13,6 +14,7 @@ require "etc"
 require "open3"
 require "stringio"
 require 'uri'
+require "yaml"
 
 require "rbs"
 
@@ -42,6 +44,10 @@ require "steep/ast/annotation/collection"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
 
+require "steep/range_extension"
+
+require "steep/interface/function"
+require "steep/interface/block"
 require "steep/interface/method_type"
 require "steep/interface/substitution"
 require "steep/interface/interface"
@@ -54,12 +60,14 @@ require "steep/subtyping/constraints"
 require "steep/subtyping/variable_variance"
 require "steep/subtyping/variable_occurrence"
 
-require "steep/signature/errors"
+require "steep/diagnostic/helper"
+require "steep/diagnostic/ruby"
+require "steep/diagnostic/signature"
+require "steep/diagnostic/lsp_formatter"
 require "steep/signature/validator"
 require "steep/source"
 require "steep/annotation_parser"
 require "steep/typing"
-require "steep/errors"
 require "steep/module_helper"
 require "steep/type_construction"
 require "steep/type_inference/context"
@@ -74,6 +82,10 @@ require "steep/type_inference/logic_type_interpreter"
 require "steep/type_inference/method_call"
 require "steep/ast/types"
 
+require "steep/index/rbs_index"
+require "steep/index/signature_symbol_provider"
+require "steep/index/source_index"
+
 require "steep/server/utils"
 require "steep/server/base_worker"
 require "steep/server/code_worker"
@@ -91,6 +103,9 @@ require "steep/project/dsl"
 require "steep/project/file_loader"
 require "steep/project/hover_content"
 require "steep/project/completion_provider"
+require "steep/project/stats_calculator"
+
+require "steep/expectations"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/check"
 require "steep/drivers/stats"
@@ -98,12 +113,12 @@ require "steep/drivers/validate"
 require "steep/drivers/annotations"
 require "steep/drivers/watch"
 require "steep/drivers/langserver"
-require "steep/drivers/signature_error_printer"
 require "steep/drivers/trace_printer"
 require "steep/drivers/print_project"
 require "steep/drivers/init"
 require "steep/drivers/vendor"
 require "steep/drivers/worker"
+require "steep/drivers/diagnostic_printer"
 
 if ENV["NO_COLOR"]
   Rainbow.enabled = false

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

@@ -23,7 +23,7 @@ module Steep
         end
 
         def to_s
-          "⟘"
+          "bot"
         end
 
         include Helper::NoFreeVariables

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

@@ -75,9 +75,23 @@ module Steep
             end
             Record.new(elements: elements, location: nil)
           when RBS::Types::Proc
-            params = params(type.type)
-            return_type = type(type.type.return_type)
-            Proc.new(params: params, return_type: return_type, location: nil)
+            func = Interface::Function.new(
+              params: params(type.type),
+              return_type: type(type.type.return_type),
+              location: type.location
+            )
+            block = if type.block
+                      Interface::Block.new(
+                        type: Interface::Function.new(
+                          params: params(type.block.type),
+                          return_type: type(type.block.type.return_type),
+                          location: type.location
+                        ),
+                        optional: !type.block.required
+                      )
+                    end
+
+            Proc.new(type: func, block: block)
           else
             raise "Unexpected type given: #{type}"
           end
@@ -145,8 +159,15 @@ module Steep
             end
             RBS::Types::Record.new(fields: fields, location: nil)
           when Proc
+            block = if type.block
+                      RBS::Types::Block.new(
+                        type: function_1(type.block.type),
+                        required: !type.block.optional?
+                      )
+                    end
             RBS::Types::Proc.new(
-              type: function_1(type.params, type.return_type),
+              type: function_1(type.type),
+              block: block,
               location: nil
             )
           when Logic::Base
@@ -156,7 +177,10 @@ module Steep
           end
         end
 
-        def function_1(params, return_type)
+        def function_1(func)
+          params = func.params
+          return_type = func.return_type
+
           RBS::Types::Function.new(
             required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
             optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
@@ -170,7 +194,7 @@ module Steep
         end
 
         def params(type)
-          Interface::Params.new(
+          Interface::Function::Params.new(
             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) },
@@ -202,13 +226,19 @@ module Steep
 
           type = Interface::MethodType.new(
             type_params: type_params,
-            return_type: type(method_type.type.return_type).subst(subst),
-            params: params(method_type.type).subst(subst),
+            type: Interface::Function.new(
+              params: params(method_type.type).subst(subst),
+              return_type: type(method_type.type.return_type).subst(subst),
+              location: method_type.location
+            ),
             block: method_type.block&.yield_self do |block|
               Interface::Block.new(
                 optional: !block.required,
-                type: Proc.new(params: params(block.type).subst(subst),
-                               return_type: type(block.type.return_type).subst(subst), location: nil)
+                type: Interface::Function.new(
+                  params: params(block.type).subst(subst),
+                  return_type: type(block.type.return_type).subst(subst),
+                  location: nil
+                )
               )
             end,
             method_decls: method_decls
@@ -242,12 +272,12 @@ module Steep
 
           type = RBS::MethodType.new(
             type_params: type_params,
-            type: function_1(method_type.params.subst(subst), method_type.return_type.subst(subst)),
+            type: function_1(method_type.type.subst(subst)),
             block: method_type.block&.yield_self do |block|
               block_type = block.type.subst(subst)
 
-              RBS::MethodType::Block.new(
-                type: function_1(block_type.params, block_type.return_type),
+              RBS::Types::Block.new(
+                type: function_1(block_type),
                 required: !block.optional
               )
             end,
@@ -338,6 +368,8 @@ module Steep
             ]
           when AST::Types::Name::Alias
             unwrap_optional(expand_alias(type))
+          when AST::Types::Boolean
+            [AST::Builtin.true_type, AST::Builtin.false_type]
           else
             [type, nil]
           end
@@ -354,7 +386,9 @@ module Steep
             when :is_a?, :kind_of?, :instance_of?
               if defined_in == RBS::BuiltinNames::Object.name && member.instance?
                 return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -363,7 +397,9 @@ module Steep
               when RBS::BuiltinNames::Object.name,
                 NilClassName
                 return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -373,7 +409,9 @@ module Steep
                 RBS::BuiltinNames::TrueClass.name,
                 RBS::BuiltinNames::FalseClass.name
                 return method_type.with(
-                  return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::Not.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -381,7 +419,17 @@ module Steep
               case defined_in
               when RBS::BuiltinNames::Module.name
                 return method_type.with(
-                  return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.type.return_type.location)
+                  )
+                )
+              when RBS::BuiltinNames::Object.name, RBS::BuiltinNames::String.name, RBS::BuiltinNames::Integer.name, RBS::BuiltinNames::Symbol.name,
+                RBS::BuiltinNames::TrueClass.name, RBS::BuiltinNames::FalseClass.name, TypeName("::NilClass")
+                # Value based type-case works on literal types which is available for String, Integer, Symbol, TrueClass, FalseClass, and NilClass
+                return method_type.with(
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ArgEqualsReceiver.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
             end
@@ -572,14 +620,17 @@ module Steep
                     method_types: type.types.map.with_index {|elem_type, index|
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [AST::Types::Literal.new(value: index)],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        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),
+                          return_type: elem_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: elem_type,
                         method_decls: Set[]
                       )
                     } + aref.method_types
@@ -591,14 +642,17 @@ module Steep
                     method_types: type.types.map.with_index {|elem_type, index|
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        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),
+                          return_type: elem_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: elem_type,
                         method_decls: Set[]
                       )
                     } + update.method_types
@@ -610,9 +664,12 @@ module Steep
                     method_types: [
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.empty,
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.empty,
+                          return_type: type.types[0] || AST::Builtin.nil_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: type.types[0] || AST::Builtin.nil_type,
                         method_decls: Set[]
                       )
                     ]
@@ -624,9 +681,12 @@ module Steep
                     method_types: [
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.empty,
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.empty,
+                          return_type: type.types.last || AST::Builtin.nil_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: type.types.last || AST::Builtin.nil_type,
                         method_decls: Set[]
                       )
                     ]
@@ -651,14 +711,17 @@ module Steep
 
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [key_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [key_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: value_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: value_type,
                         method_decls: Set[]
                       )
                     } + ref.method_types
@@ -671,14 +734,16 @@ module Steep
                       key_type = Literal.new(value: key_value, location: nil)
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [key_type, value_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [key_type, value_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: value_type,
+                          location: nil),
                         block: nil,
-                        return_type: value_type,
                         method_decls: Set[]
                       )
                     } + update.method_types
@@ -691,14 +756,18 @@ module Steep
             interface(Builtin::Proc.instance_type, private: private, self_type: self_type).tap do |interface|
               method_type = Interface::MethodType.new(
                 type_params: [],
-                params: type.params,
-                return_type: type.return_type,
-                block: nil,
+                type: type.type,
+                block: type.block,
                 method_decls: Set[]
               )
 
-              interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type])
               interface.methods[:call] = Interface::Interface::Entry.new(method_types: [method_type])
+
+              if type.block_required?
+                interface.methods.delete(:[])
+              else
+                interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type.with(block: nil)])
+              end
             end
 
           when Logic::Base