steep 1.7.0.dev.3 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c30f769d118a31c069ae146f976dc3df96b71acfa50659e6f03b00bdc1624da7
-  data.tar.gz: '064953d68e749654f069f2ea215746366a58506406ec5977826f5cf73552f779'
+  metadata.gz: ee680022ab2333d1fcfeff84ee0513c389ccfb6cf52fbc04f3f53edace112931
+  data.tar.gz: 400fd763d24b8154fea38900c988cf651c6a0e646485a1aa4d4e6c5ba285a453
 SHA512:
-  metadata.gz: 4ce31d8368b84b72284eb331606a6f1c15b3843a2c13a01770bcac35c4f9fa35ab5a62617a4d13c913c482b1775fc043265a8fbdb5a58e7598e9ad92a2246fda
-  data.tar.gz: 206491dcd015533b092afe61277f48e28e288693c9ffadaa85aa855b0616ab9f64ba7001b297a7387432fec3492aed55f16ac5ebba3b379cb7bf79575249700c
+  metadata.gz: 6836114d1f2e78eea1b2d19528a480ca234cc02f1339d8c70543e20a6c7b969d59b11a9434290e0fa2a4116ffe8f2b646bb0a9c642a0978102e5752be06ae808
+  data.tar.gz: 0476bc765f54bba0442aafdd08a64c2985a0d16fe25efaac69f9c3ddad8cca44628d78d1fb62e2c5e0727627cdcddd1a7cdc5987e3de6ef4cdc1e1a5761bcb99

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 # CHANGELOG
 
+## 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/narrowing.md

@@ -65,7 +65,7 @@ It immediately type checks the left hand side, but with *conditional mode*. Cond
 x && y
 ```
 
-Going down again, it gets a typing `x: String?` and `y: String?. It runs a type narrowing, to obtain a result both of `x` and `y` are `String` for truthy result, both of `x` and `y` are `String?` for falsy result. The two environments should be propagated to the upper node, because the parent node is also `&&` which is a subject of type narrowing. So, it returns an `ENV` type, `String?` for original type, `{ x: String, y: String }` for truthy result, and `{ x: String?, y: String? }` for falsy result.
+Going down again, it gets a typing `x: String?` and `y: String?`. It runs a type narrowing, to obtain a result both of `x` and `y` are `String` for truthy result, both of `x` and `y` are `String?` for falsy result. The two environments should be propagated to the upper node, because the parent node is also `&&` which is a subject of type narrowing. So, it returns an `ENV` type, `String?` for original type, `{ x: String, y: String }` for truthy result, and `{ x: String?, y: String? }` for falsy result.
 
 Going up to the outer `&&` expression. The left hand side has `ENV` type, and then the right hand side is type checked based on the truthy environment (because of the semantics of `&&` expression.) Both `x` and `y` are `String` and it type checks. The type of the whole expression union of `String` and the falsy part of the original type -- `nil`.
 ## Union type partition

data/doc/shape.md

@@ -0,0 +1,176 @@
+# Shapes
+
+A *shape* is a data structure, which contains the set of available methods and their types, which is associated with a type. Steep uses shapes to type check method calls -- it calculates the shape of the type of the receiver, checks if the called method is defined on the shape and the arguments are compatible with the method, and calculates the return type.
+
+Assume an interface `_Foo` is defined as follows:
+
+```rbs
+interface _Foo
+  def foo: () -> String
+
+  def bar: () -> self
+end
+```
+
+The shape of `_Foo` will be the following:
+
+```
+Shape (_Foo) {
+  foo: () -> String,
+  bar: () -> _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.
+
+```
+Shape ([Integer, String]) {
+  []: (0) -> Integer
+    | (1) -> String
+    | (Integer) -> (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
+interface _Foo
+  def itself: () -> self
+end
+```
+
+The `self` types included in the shape of `_Foo` type should be resolved to `_Foo` type.
+
+```
+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
+interface _Foo[A]
+  def get: () -> A
+end
+```
+
+The shape of `_Foo[self]` has `self` type as its type argument, and we want the `self` type preserved after the shape calculation.
+
+```
+Shape (_Foo[self]) {
+  get: () -> self
+}
+```
+
+We often use `self` types as the return type of a method.
+
+```rbs
+class Foo
+  def foo: () -> self
+end
+```
+
+So, the implementation of `foo` might use `self` node to return `self` type.
+
+```rb
+class Foo
+  def foo
+    # @type var foo: _Foo[self]
+    foo = ...
+    foo.get
+  end
+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
+class Foo
+  def foo
+    self.itself
+  end
+end
+```
+
+This is a straightforward case, because the type of `self` is `self` itself. Calculate the shape of it, but keep the `self` types in the shape.
+
+```
+Shape (self) {
+  itself: () -> self
+}
+```
+
+If `self` is a union type, or something built with a type constructor, the shape calculation gets complicated.
+
+```rbs
+class Foo
+  def foo: () -> Integer
+end
+
+class Bar
+  def foo: () -> self
+end
+```
+
+What is the expected shape of `self` where the type of `self` is `Foo | Bar`?
+
+The shape of a union type is straightforward. It calculates the shape of each type, and then it calculates a union of the shape.
+
+We do the same for the case with `self` types, but it results in slightly incorrect shapes.
+
+```
+Shape (Foo) {
+  foo: () -> Integer
+}
+
+Shape (Bar) {
+  foo: () -> self   # self is preserved, because the shape of `self` is being calculated
+}
+
+Shape (Foo | Bar) {
+  foo: () -> (Integer | self)
+}
+```
+
+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
+2. `class`/`instance` types in generics type arguments of interfaces/instances are preserved
+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.
+
+It is implemented in `Steep::Interface::Shape::Entry` and used to make the shape calculation of a union type faster.

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/ast/types/factory.rb

@@ -212,27 +212,36 @@ module Steep
           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)) },
-            rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            trailing_positionals: [],
-            required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            return_type: type_1(return_type)
-          )
+          if params
+            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)) },
+              rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              trailing_positionals: [],
+              required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              return_type: type_1(return_type)
+            )
+          else
+            RBS::Types::UntypedFunction.new(return_type: type_1(return_type))
+          end
         end
 
         def params(type)
-          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) },
-            required_keywords: type.required_keywords.transform_values {|param| type(param.type) },
-            optional_keywords: type.optional_keywords.transform_values {|param| type(param.type) },
-            rest_keywords: type.rest_keywords&.yield_self {|param| type(param.type) }
-          )
+          case type
+          when RBS::Types::Function
+            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) },
+              required_keywords: type.required_keywords.transform_values {|param| type(param.type) },
+              optional_keywords: type.optional_keywords.transform_values {|param| type(param.type) },
+              rest_keywords: type.rest_keywords&.yield_self {|param| type(param.type) }
+            )
+          when RBS::Types::UntypedFunction
+            nil
+          end
         end
 
         def type_param(type_param)

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

@@ -57,9 +57,11 @@ module Steep
         include Helper::ChildrenLevel
 
         def level
-          children = type.params.each_type.to_a + [type.return_type]
+          children = type.params&.each_type.to_a + [type.return_type]
           if block
-            children.push(*block.type.params.each_type.to_a)
+            if block.type.params
+              children.push(*block.type.params.each_type.to_a)
+            end
             children.push(block.type.return_type)
           end
           if self_type
@@ -83,13 +85,16 @@ module Steep
 
         def one_arg?
           params = type.params
-
-          params.required.size == 1 &&
-            params.optional.empty? &&
-            !params.rest &&
-            params.required_keywords.empty? &&
-            params.optional_keywords.empty? &&
-            !params.rest_keywords
+          if params
+            params.required.size == 1 &&
+              params.optional.empty? &&
+              !params.rest &&
+              params.required_keywords.empty? &&
+              params.optional_keywords.empty? &&
+              !params.rest_keywords
+          else
+            true
+          end
         end
 
         def back_type

data/lib/steep/interface/block.rb

@@ -82,7 +82,7 @@ module Steep
       def +(other)
         optional = self.optional? || other.optional?
         type = Function.new(
-          params: self.type.params + other.type.params,
+          params: self.type.params && other.type.params ? self.type.params + other.type.params : nil,
           return_type: AST::Types::Union.build(types: [self.type.return_type, other.type.return_type]),
           location: nil
         )

data/lib/steep/interface/builder.rb

@@ -62,6 +62,7 @@ module Steep
       def shape(type, config)
         Steep.logger.tagged "shape(#{type})" do
           if shape = raw_shape(type, config)
+            # Optimization that skips unnecesary substittuion
             if type.free_variables.include?(AST::Types::Self.instance)
               shape
             else

data/lib/steep/interface/function.rb

@@ -1008,7 +1008,7 @@ module Steep
       def free_variables
         @fvs ||= Set[].tap do |fvs|
           # @type var fvs: Set[AST::Types::variable]
-          fvs.merge(params.free_variables)
+          fvs.merge(params.free_variables) if params
           fvs.merge(return_type.free_variables)
         end
       end
@@ -1016,7 +1016,7 @@ module Steep
       def subst(s)
         return self if s.empty?
 
-        ps = params.subst(s)
+        ps = params.subst(s) if params
         ret = return_type.subst(s)
 
         if ps == params && ret == return_type
@@ -1032,7 +1032,7 @@ module Steep
 
       def each_type(&block)
         if block
-          params.each_type(&block)
+          params&.each_type(&block)
           yield return_type
         else
           enum_for :each_type
@@ -1043,7 +1043,7 @@ module Steep
 
       def map_type(&block)
         Function.new(
-          params: params.map_type(&block),
+          params: params&.map_type(&block),
           return_type: yield(return_type),
           location: location
         )
@@ -1058,11 +1058,19 @@ module Steep
       end
 
       def to_s
-        "#{params} -> #{return_type}"
+        if params
+          "#{params} -> #{return_type}"
+        else
+          "(?) -> #{return_type}"
+        end
       end
 
       def closed?
-        params.closed? && return_type.free_variables.empty?
+        if params
+          params.closed? && return_type.free_variables.empty?
+        else
+          return_type.free_variables.empty?
+        end
       end
     end
   end

data/lib/steep/interface/method_type.rb

@@ -61,7 +61,7 @@ module Steep
           type.each_type(&block)
           if block()
             yield(block().self_type) if block().self_type
-            block().type.params.each_type(&block)
+            block().type.params&.each_type(&block)
             yield(block().type.return_type)
           end
         else
@@ -119,7 +119,7 @@ module Steep
         self.class.new(
           type_params: type_params,
           type: Function.new(
-            params: type.params.subst(s1) + other.type.params.subst(s2),
+            params: type.params && other.type.params ? type.params.subst(s1) + other.type.params.subst(s2) : nil,
             return_type: AST::Types::Union.build(
               types: [type.return_type.subst(s1), other.type.return_type.subst(s2)]
             ),
@@ -250,10 +250,13 @@ module Steep
                 nil
               end
 
-            # Return when the two block parameters are imcompatible.
-            return unless b.type.params & ob.type.params
-
-            block_params = b.type.params | ob.type.params or return
+            if b.type.params && ob.type.params
+              # Return when the two block parameters are imcompatible.
+              return unless b.type.params & ob.type.params
+              block_params = b.type.params | ob.type.params or return
+            else
+              block_params = b.type.params || ob.type.params
+            end
 
             block_return_type = AST::Types::Intersection.build(types: [b.type.return_type, ob.type.return_type])
             block_type = Function.new(params: block_params, return_type: block_return_type, location: nil)
@@ -285,7 +288,12 @@ module Steep
       def &(other)
         return self if self == other
 
-        params = self.type.params | other.type.params or return
+        if self.type.params && other.type.params
+          params = self.type.params | other.type.params or return
+        else
+          params = self.type.params || other.type.params
+        end
+        
         block =
           case
           when (b = self.block) && (ob = other.block)

data/lib/steep/project/pattern.rb

@@ -46,10 +46,9 @@ module Steep
 
       def test_string(path, patterns, prefixes)
         string = path.to_s
-        extension = path.extname
 
         patterns.any? {|pat| File.fnmatch(pat, string, File::FNM_PATHNAME) } ||
-          prefixes.any? {|prefix| string.start_with?(prefix) && extension == ext }
+          prefixes.any? {|prefix| File.fnmatch("#{prefix}**/*#{ext}", string, File::FNM_PATHNAME) }
       end
     end
   end