steep 0.35.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ddd53798b724f6fd1a93d869b03a3864db04bed448552a75dadeabe8d1bc51e
-  data.tar.gz: c85f6c58a010ed11dfc1041f8ba98007e0f557d7bda133222b94915dfed0d6ca
+  metadata.gz: 725a6432404ca94fa643ba89ed2028d7b3923ece4031512ebea88ebbdc4fd01e
+  data.tar.gz: 957a95acbda38474f1a796f829f8cf098b69484a8ddf42bd39e2c2be935a961e
 SHA512:
-  metadata.gz: 79a7742bdef0d368aa2dceaa528cf3e4bc74bccefafc0d6c366aa94994917e7d5560c8d4fd6f03adf0d50c3b8536d80d7e998bba3a9dc5cb872c7047c0079cba
-  data.tar.gz: 512b5bdf6efd6e465d5e3147de2df6cafb549fe68e05890efc13fffcc763b0cec1c48005a1734b6ade2cd120fa48059c435c20bad4b9998b1d15a0b4f557f615
+  metadata.gz: 363a04610a81d4652541c9e5856705f7317a8b4e92a2074dc460b5f34e19f8eb5bfd080826c3a61a41414668d22d0352e4b300d1ce09c659243ef8c06492fc22
+  data.tar.gz: 33b8d47d5290acea68f1f07ee74a6129ad0a2568fff2ddc783b7910f2ed55ae2d6d6b6f0b1b90b8dea773bfab0c9cc7ccc70723ab5aee75db3e3a0f997b93fe9

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,37 @@
 
 ## master
 
+## 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))
+* Type-case improvement ([#259](https://github.com/soutaro/steep/pull/259))
+* Subtyping between `bool` and logic types ([#258](https://github.com/soutaro/steep/pull/258))
+
 ## 0.35.0 (2020-11-14)
 
 * Support third party RBS repository ([#231](https://github.com/soutaro/steep/pull/231), [#254](https://github.com/soutaro/steep/pull/254), [#255](https://github.com/soutaro/steep/pull/255))

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,49 @@
+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
+
+test_dirs.each do |dir|
+  test = dir + "test.yaml"
+
+  if test.file?
+    content = YAML.load_file(test)
+  else
+    content = { "test" => {} }
+  end
+
+  puts "Rebaselining #{dir}..."
+
+  command = content["command"] || "steep check"
+  puts "  command: #{command}"
+
+  output, _ = Open3.capture2(command, chdir: dir.to_s)
+
+  diagnostics = output.split(/\n\n/).each.with_object({}) do |message, hash|
+    if message =~ /\A([^:]+):\d+:\d+:/
+      path = $1
+      hash[path] ||= { "diagnostics" => [] }
+      hash[path]["diagnostics"] << message.chomp + "\n"
+    end
+  end
+
+  content["test"].each_key do |path|
+    unless diagnostics.key?(path)
+      diagnostics[path] = { "diagnostics" => [] }
+    end
+  end
+
+  content["test"] = diagnostics.keys.sort.each.with_object({}) do |key, hash|
+    hash[key] = diagnostics[key]
+  end
+
+  test.open("w") do |io|
+    YAML.dump(content, io, header: false)
+  end
+end

data/bin/output_test.rb

@@ -0,0 +1,93 @@
+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
+
+success = true
+
+test_dirs.each do |dir|
+  test = dir + "test.yaml"
+
+  next unless test.file?
+
+  puts "Running test #{dir}..."
+
+  content = YAML.load_file(test)
+
+  command = content["command"] || "steep check"
+  puts "  command: #{command}"
+
+  output, _ = Open3.capture2(command, chdir: dir.to_s)
+
+  if @verbose
+    puts "  Raw output:"
+    output.split(/\n/).each do |line|
+      puts "  > #{line.chomp}"
+    end
+  end
+
+  diagnostics = output.split(/\n\n/).each.with_object({}) do |d, hash|
+    if d =~ /\A([^:]+):\d+:\d+:/
+      path = $1
+      hash[path] ||= []
+      hash[path] << (d.chomp + "\n")
+    end
+  end
+
+  content["test"].each do |path, test|
+    puts "  Checking: #{path}..."
+
+    fail_expected = test["fail"] || false
+
+    expected_diagnostics = test["diagnostics"]
+    reported_diagnostics = (diagnostics[path] || [])
+
+    puts "    # of expected: #{expected_diagnostics.size}, # of reported: #{reported_diagnostics.size}"
+
+    unexpected_diagnostics = reported_diagnostics.reject {|d| expected_diagnostics.include?(d) }
+    missing_diagnostics = expected_diagnostics.reject {|d| reported_diagnostics.include?(d) }
+
+    unexpected_diagnostics.each do |d|
+      puts "    Unexpected diagnostics:"
+      d.split(/\n/).each do |line|
+        puts "      + #{line.chomp}"
+      end
+    end
+
+    missing_diagnostics.each do |d|
+      puts "    Missing diagnostics:"
+      d.split(/\n/).each do |line|
+        puts "      - #{line.chomp}"
+      end
+    end
+
+    if unexpected_diagnostics.empty? && missing_diagnostics.empty?
+      puts "    👍"
+    else
+      if fail_expected
+        puts "    🚨 (expected failure)"
+      else
+        puts "    🚨"
+        success = false
+      end
+    end
+  end
+end
+
+if success
+  puts "All tests ok! 👏"
+else
+  puts "Errors detected! 🤮"
+  exit 1
+end

data/lib/steep.rb

@@ -42,6 +42,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 +58,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 +80,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 +101,7 @@ 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/drivers/utils/driver_helper"
 require "steep/drivers/check"
 require "steep/drivers/stats"
@@ -98,12 +109,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