steep 1.7.0.dev.4 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17795ed14e183d6e8858e6ea8f57f71dbd3cdced0e4d9cf7e43c646188e486cd
-  data.tar.gz: 7005e9d96f44f23a47f1844597b86fd3d774f000b1de5cf100d235e68c56a0b5
+  metadata.gz: 6031a713ec97be707b33a667121cba53ba966e30c0949c1070c62ccf4c698596
+  data.tar.gz: 01cd81e06eb1228a4b01070e0f6a12098fe10ee2cfe7620434a629f70e504005
 SHA512:
-  metadata.gz: e178baa7a185edaafb359032266bfa7f29d082c9da30ca418e5ef4030b5723423f3f36ba4165a640d996e252bb91883dcfe55b1f750f51c3153452b368e5a9ee
-  data.tar.gz: 8919d4c047097e7e7fd63ecba71ae96f412a56588c7b6ff1d381838d2d935d2ba7dc382ca83fe5b679f35ebbe298460e80e87047c88b6ebcc5e3e6ef258e2535
+  metadata.gz: abfac9447afb1c68ba1702738f1ffd67c9b2cddc860a84a4552b963eafd3e9936987c2085d25b565b8834bc70be49bf5271daa28ac02926db12a5d056cc0780b
+  data.tar.gz: '0871a287d3bc466c58a9106def0ed944e682c862f5ab30d849cfd9dfdcbd9aefb49b376791c6a61211f0cfefef000d05f62e7b0ce3a5045faf9f2f9a39eadc0d'

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 # CHANGELOG
 
+## 1.7.1 (2024-06-12)
+
+### Type checker core
+
+* Fix subtyping issues ([#1165](https://github.com/soutaro/steep/pull/1165))
+
+## 1.7.0 (2024-06-07)
+
+### Type checker core
+
+* Implement untyped function params ([#1101](https://github.com/soutaro/steep/pull/1101))
+* Fix method call type narrowing with`||` operator ([#1085](https://github.com/soutaro/steep/pull/1085))
+* Refactor `Interface::Builder` ([#1081](https://github.com/soutaro/steep/pull/1081))
+* Fix UnexpectedError with unnamed arguments  ([#1041](https://github.com/soutaro/steep/pull/1041))
+* Abort if subtyping fails to (possible) infinite loop ([#1055](https://github.com/soutaro/steep/pull/1055))
+* Ignore diagnostics by `steep:ignore` comment ([#1034](https://github.com/soutaro/steep/pull/1034))
+* Make defined? accept any type ([#1031](https://github.com/soutaro/steep/pull/1031))
+* Refactor case-when syntax ([#999](https://github.com/soutaro/steep/pull/999))
+* Update `Steep::Subtyping::Check#check` types ([#972](https://github.com/soutaro/steep/pull/972))
+
+### Commandline tool
+
+* Improve wildcard handling in pattern matching for directory paths ([#1121](https://github.com/soutaro/steep/pull/1121))
+* Fix issue with wildcard expansion in FileLoader ([#1113](https://github.com/soutaro/steep/pull/1113))
+* Avoid unnecessary calling `RBS::Location#to_s` on debug log ([#1092](https://github.com/soutaro/steep/pull/1092))
+* Better recovery from collection problems ([#987](https://github.com/soutaro/steep/pull/987))
+* Handle absolute path ([#975](https://github.com/soutaro/steep/pull/975))
+* Default to check the entire current directory when there is no `Steepfile` ([#968](https://github.com/soutaro/steep/pull/968))
+
+### Language server
+
+* Fix variable untyped hover issue in rescue clause ([#1147](https://github.com/soutaro/steep/pull/1147))
+* Handle `$/file/reset` request in interaction worker ([#1122](https://github.com/soutaro/steep/pull/1122))
+* Skip pending UI jobs ([#1035](https://github.com/soutaro/steep/pull/1035))
+* Fix no method error ([#1040](https://github.com/soutaro/steep/pull/1040))
+* Implement completion for comments ([#1039](https://github.com/soutaro/steep/pull/1039))
+* Fix signature help ([#1038](https://github.com/soutaro/steep/pull/1038))
+
+### Miscellaneous
+
+* Revise rake tasks ([#1156](https://github.com/soutaro/steep/pull/1156))
+* Update `steep.gemspec` ([#1155](https://github.com/soutaro/steep/pull/1155))
+* Add `Steep::RakeTask` ([#995](https://github.com/soutaro/steep/pull/995))
+* Stop to distribute sig dir ([#1144](https://github.com/soutaro/steep/pull/1144))
+* Update gem-rbs-collection.md ([#1127](https://github.com/soutaro/steep/pull/1127))
+* Add shape docs ([#1089](https://github.com/soutaro/steep/pull/1089))
+* Ignore smoke tests when packaging gem ([#962](https://github.com/soutaro/steep/pull/962))
+* Fix setup for Ruby 3.3 ([#1000](https://github.com/soutaro/steep/pull/1000))
+
 ## master
 
 ## 1.6.0 (2023-11-09)

data/README.md

@@ -219,6 +219,24 @@ Steep implements some of the Language Server Protocol features.
 
 Other LSP supporting tools may work with Steep where it starts the server as `steep langserver`.
 
+## Rake Tasks
+
+Steep comes with a set of configurable Rake tasks.
+
+```ruby
+# Rakefile
+
+require "steep/rake_task"
+Steep::RakeTask.new do |t|
+  t.check.severity_level = :error
+  t.watch.verbose
+end
+
+task default: [:steep]
+```
+
+Use `bundle exec rake -T` to see all available tasks.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/doc/shape.md

@@ -24,7 +24,9 @@ Shape (_Foo) {
 Note that the `self` type in the example is resolved to `_Foo` during shape calculation.
 
 The shape calculation of an object is straightforward. Calculate a `RBS::Definition` of a class singleton/instance, or an interface, and translate the data structure to a `Shape` object. But there are a few things to consider.
+
 ## Tuple, record, and proc types
+
 The shape of tuple, record, or proc types are based on their base types -- Array, Hash, or Proc classes --, but with specialized method types.
 
 ```
@@ -37,16 +39,22 @@ Shape ([Integer, String]) {
 ```
 
 The specialization is implemented as a part of shape calculation.
+
 ## Special methods
+
 Steep recognizes some special methods for type narrowing, including `#is_a?`, `#===`, `#nil?`, ... These methods are defined with normal RBS syntax, but the method types in shapes are transformed to types using logic types.
 
 The shape calculation inserts the specialized methods with these special methods.
+
 ## `self` types
+
 There are two cases of `self` types to consider during shape calculation.
 
 1. `self` types included in the shape of a type
 2. `self` types included in given types
+
 ### 1. `self` types included in the shape of a type
+
 `self` types may be included in a class or interface definition.
 
 ```rbs
@@ -62,7 +70,9 @@ Shape (_Foo) {
   itself: () -> _Foo
 }
 ```
+
 ### 2. `self` types included in given types
+
 Unlike `self` types included in definitions, `self` types in given types should be preserved.
 
 ```rbs
@@ -100,7 +110,9 @@ end
 ```
 
 We want the type of `foo.get` to be `self`, not `Foo`, to avoid a type error being detected.
+
 ## Shape of `self` types
+
 We also want `self` type if `self` is the type of the shape.
 
 ```rb
@@ -154,7 +166,9 @@ Shape (Foo | Bar) {
 So, the resulting type of `self.foo` where the type of `self` is `Foo | Bar`, would be `Integer | Foo | Bar`. But, actually, it won't be `Foo` because the `self` comes from `Bar`.
 
 This is an incorrect result, but Steep is doing this right now.
+
 ## `class` and `instance` types
+
 The shape calculation provides limited support for `class` and `instance` types.
 
 1. `class`/`instance` types from the definition are resolved
@@ -162,13 +176,17 @@ The shape calculation provides limited support for `class` and `instance` types.
 3. Shape of `class`/`instance` types are resolved to configuration's `class_type` and `instance_type`, and the translated types are used to calculate the shape
 
 It's different from `self` types except case #2. The relationship between `self`/`class`/`instance` is not trivial in Ruby. All of them might be resolved to any type, which means calculating one from another of them is simply impossible.
+
 ## Public methods, private methods
+
 `Shape` objects have a flag of if the shape is for *public* method calls or *private* method calls. Private method call is a form of `foo()` or `self.foo()` -- when the receiver is omitted or `self`. Public method calls are anything else.
 
 The shape calculation starts with *private methods*, and the `Shape#public_shape` method returns another shape that only has *public* methods.
 
 > Note that the private shape calculation is required even on public method calls. This means a possible chance of future optimizations.
+
 ## Lazy method type calculation
+
 We rarely need all of the methods available for an object. If we want to type check a method call, we only need the method type of that method. All other methods can be just ignored.
 
 *Lazy method type calculation* is introduced for that case. Instead of calculating the types of all of the methods, it registers a block that computes the method type.

data/guides/src/gem-rbs-collection/gem-rbs-collection.md

@@ -12,30 +12,13 @@ Run rbs-collection-init to start setup.
 $ rbs collection init
 ```
 
-You have to edit the generated `rbs_collection.yaml` file. Add a few lines under gems section.
-
-```yaml
-# Download sources
-sources:
-  - name: ruby/gem_rbs_collection
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    revision: main
-    repo_dir: gems
-
-# A directory to install the downloaded RBSs
-path: .gem_rbs_collection
-
-gems:
-  # Skip loading rbs gem's RBS.
-  # It's unnecessary if you don't use rbs as a library.
-  - name: rbs
-    ignore: true
-  - name: steep
-    ignore: true
-  - name: rbs_rails     # Add these lines if you use rbs_rails
-    ignore: true
-  - name: rbs_protobuf  # Add these lines if you use rbs_protobuf
-    ignore: true
+You have to edit your `Gemfile`. Specify `require: false` for gems for which you do not want type definitions.
+
+```ruby
+gem 'rbs', require: false
+gem 'steep, require: false
+gem 'rbs_rails', require: false
+gem 'rbs_protobuf', require: false
 ```
 
 Once you save the file, run the install command.

data/lib/steep/interface/builder.rb

@@ -9,8 +9,6 @@ module Steep
           @class_type = class_type
           @instance_type = instance_type
           @variable_bounds = variable_bounds
-
-          validate
         end
 
         def self.empty
@@ -23,11 +21,16 @@ module Steep
           end
         end
 
-        def validate
+        def validate_self_type
           validate_fvs(:self_type, self_type)
+        end
+
+        def validate_instance_type
           validate_fvs(:instance_type, instance_type)
+        end
+
+        def validate_class_type
           validate_fvs(:class_type, class_type)
-          self
         end
 
         def validate_fvs(name, type)
@@ -37,6 +40,7 @@ module Steep
               raise "#{name} cannot include 'self' type: #{type}"
             end
             if fvs.include?(AST::Types::Instance.instance)
+              Steep.logger.fatal { "#{name} cannot include 'instance' type: #{type}" }
               raise "#{name} cannot include 'instance' type: #{type}"
             end
             if fvs.include?(AST::Types::Class.instance)
@@ -87,12 +91,15 @@ module Steep
       def raw_shape(type, config)
         case type
         when AST::Types::Self
+          config.validate_self_type
           self_type = config.self_type or raise
           self_shape(self_type, config)
         when AST::Types::Instance
+          config.validate_instance_type
           instance_type = config.instance_type or raise
           raw_shape(instance_type, config)
         when AST::Types::Class
+          config.validate_class_type
           klass_type = config.class_type or raise
           raw_shape(klass_type, config)
         when AST::Types::Name::Singleton

data/lib/steep/rake_task.rb

@@ -0,0 +1,132 @@
+require "rake"
+require "rake/tasklib"
+require "steep/cli"
+
+module Steep
+  # Provides Rake tasks for running Steep commands.
+  #
+  # require "steep/rake_task"
+  # Steep::RakeTask.new do |t|
+  #   t.check.severity_level = :error
+  #   t.watch.verbose
+  #   t.stats << "--format=table"
+  # end
+  class RakeTask < Rake::TaskLib # steep:ignore UnknownConstant
+    attr_accessor :name
+
+    def self.available_commands
+      %i(init check stats binstub project watch)
+    end
+
+    def initialize(name = :steep, cli_runner = default_cli_runner)
+      super()
+
+      @name = name
+
+      configuration = TaskConfiguration.new
+
+      yield configuration if block_given?
+
+      define_tasks(configuration, cli_runner)
+    end
+
+    private
+
+    # :nodoc:
+    class TaskConfiguration
+      def initialize
+        @commands = {}
+      end
+
+      def method_missing(command)
+        if respond_to?(command)
+          @commands[command] ||= CommandConfiguration.new
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        RakeTask.available_commands.include?(name) || super
+      end
+
+      def options(command)
+        @commands[command]&.to_a || []
+      end
+    end
+
+    # :nodoc:
+    class CommandConfiguration
+      def initialize
+        @options = []
+      end
+
+      def method_missing(name, value = nil)
+        option = "--#{name.to_s.gsub(/_/, '-').gsub(/=/, '')}"
+        option << "=#{value}" if value
+
+        self << option
+      end
+
+      def respond_to_missing?(_name)
+        true
+      end
+
+      def <<(value)
+        @options << value
+        self
+      end
+
+      def to_a
+        @options
+      end
+    end
+
+    def default_cli_runner
+      lambda do |arguments|
+        require "steep"
+
+        cli = Steep::CLI.new(
+          stdout: $stdout,
+          stdin: $stdin,
+          stderr: $stderr,
+          argv: arguments
+        )
+
+        cli.run
+      end
+    end
+
+    def define_tasks(configuration, cli_runner)
+      namespace name do
+        RakeTask.available_commands.each do |command|
+          desc "Run steep #{command}"
+          task command do |_, args|
+            configured_options = configuration.options(command)
+
+            argv = [
+              command.to_s,
+              *configured_options,
+              *args.extras
+            ]
+
+            result = cli_runner[argv]
+
+            raise "Steep failed" if result.nonzero?
+          end
+        end
+
+        desc "Run steep help"
+        task "help" do
+          arguments = ["--help"]
+
+          cli_runner[arguments]
+        end
+      end
+
+      # Default steep task to steep:check
+      desc "Run steep check" unless ::Rake.application.last_description # steep:ignore UnknownConstant
+      task name => ["#{name}:check"]
+    end
+  end
+end