steep 1.7.0.dev.2 → 1.7.0.dev.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0646b6c1cb596e684bc62461ee2dac160e134bc7e126f447df8f6e46a535c8b6
-  data.tar.gz: fda1f8d1903253537fec79679dd88f3579404372d4fc611a0d4b9d085e5b3502
+  metadata.gz: 17795ed14e183d6e8858e6ea8f57f71dbd3cdced0e4d9cf7e43c646188e486cd
+  data.tar.gz: 7005e9d96f44f23a47f1844597b86fd3d774f000b1de5cf100d235e68c56a0b5
 SHA512:
-  metadata.gz: 46fe48e86a4fe74482765debeb255e1b806298fb797603ebf292443432506e80ac7ffb7aa964b6331e4f71d2f4e607379340834a6f66866d75bc8c0ca4b73633
-  data.tar.gz: c822e0bf8a0484914423ece12d3d38bebf4102d6f63b1eb79f779cc3bf8aa9b909d34b189a594cf5d0a4f607ed0474d7b9bb2ed6a6c6d400212e329f4d5a8e96
+  metadata.gz: e178baa7a185edaafb359032266bfa7f29d082c9da30ca418e5ef4030b5723423f3f36ba4165a640d996e252bb91883dcfe55b1f750f51c3153452b368e5a9ee
+  data.tar.gz: 8919d4c047097e7e7fd63ecba71ae96f412a56588c7b6ff1d381838d2d935d2ba7dc382ca83fe5b679f35ebbe298460e80e87047c88b6ebcc5e3e6ef258e2535

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.7.0.dev.2)
+    steep (1.7.0.dev.4)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)
@@ -12,7 +12,7 @@ PATH
       logger (>= 1.3.0)
       parser (>= 3.1)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 3.1.0)
+      rbs (>= 3.5.0.pre)
       securerandom (>= 0.1)
       strscan (>= 1.0.0)
       terminal-table (>= 2, < 4)
@@ -33,53 +33,51 @@ GEM
       tzinfo (~> 2.0)
     ast (2.4.2)
     base64 (0.2.0)
-    bigdecimal (3.1.6)
+    bigdecimal (3.1.8)
     concurrent-ruby (1.2.3)
     connection_pool (2.4.1)
-    csv (3.2.8)
-    debug (1.9.1)
+    csv (3.3.0)
+    debug (1.9.2)
       irb (~> 1.10)
       reline (>= 0.3.8)
-    drb (2.2.0)
-      ruby2_keywords
+    drb (2.2.1)
     ffi (1.16.3)
     fileutils (1.7.2)
-    i18n (1.14.1)
+    i18n (1.14.5)
       concurrent-ruby (~> 1.0)
     io-console (0.7.2)
-    irb (1.11.1)
-      rdoc
+    irb (1.13.1)
+      rdoc (>= 4.0.0)
       reline (>= 0.4.2)
-    json (2.7.1)
+    json (2.7.2)
     language_server-protocol (3.17.0.3)
-    listen (3.8.0)
+    listen (3.9.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     logger (1.6.0)
-    minitest (5.22.2)
+    minitest (5.22.3)
     minitest-hooks (1.5.1)
       minitest (> 5.3)
     minitest-slow_test (0.2.0)
       minitest (>= 5.0)
     mutex_m (0.2.0)
-    parser (3.3.0.5)
+    parser (3.3.1.0)
       ast (~> 2.4.1)
       racc
     psych (5.1.2)
       stringio
     racc (1.7.3)
     rainbow (3.1.1)
-    rake (13.1.0)
+    rake (13.2.1)
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (3.4.4)
+    rbs (3.5.0.pre.2)
       abbrev
-    rdoc (6.6.2)
+    rdoc (6.6.3.1)
       psych (>= 4.0.0)
-    reline (0.4.2)
+    reline (0.5.6)
       io-console (~> 0.5)
-    ruby2_keywords (0.0.5)
     securerandom (0.3.1)
     stackprof (0.2.26)
     stringio (3.1.0)

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/gemfile_steep/Gemfile.lock

@@ -2,7 +2,7 @@ GEM
   remote: https://rubygems.org/
   specs:
     abbrev (0.1.2)
-    activesupport (7.1.3)
+    activesupport (7.1.3.2)
       base64
       bigdecimal
       concurrent-ruby (~> 1.0, >= 1.0.2)
@@ -14,25 +14,24 @@ GEM
       tzinfo (~> 2.0)
     ast (2.4.2)
     base64 (0.2.0)
-    bigdecimal (3.1.6)
+    bigdecimal (3.1.8)
     concurrent-ruby (1.2.3)
     connection_pool (2.4.1)
-    csv (3.2.8)
-    drb (2.2.0)
-      ruby2_keywords
+    csv (3.3.0)
+    drb (2.2.1)
     ffi (1.16.3)
     fileutils (1.7.2)
-    i18n (1.14.1)
+    i18n (1.14.5)
       concurrent-ruby (~> 1.0)
-    json (2.7.1)
+    json (2.7.2)
     language_server-protocol (3.17.0.3)
-    listen (3.8.0)
+    listen (3.9.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     logger (1.6.0)
-    minitest (5.22.2)
+    minitest (5.22.3)
     mutex_m (0.2.0)
-    parser (3.3.0.5)
+    parser (3.3.1.0)
       ast (~> 2.4.1)
       racc
     racc (1.7.3)
@@ -42,9 +41,8 @@ GEM
       ffi (~> 1.0)
     rbs (3.4.4)
       abbrev
-    ruby2_keywords (0.0.5)
     securerandom (0.3.1)
-    steep (1.7.0.dev.1)
+    steep (1.7.0.dev.3)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)

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

@@ -29,6 +29,10 @@ module Steep
               enum_for :each_child
             end
           end
+
+          def map_type
+            self
+          end
         end
       end
     end

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

@@ -80,6 +80,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          self.class.build(
+            types: each_child.map(&block),
+            location: location
+          )
+        end
+
         def level
           [0] + level_of_children(types)
         end

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

@@ -50,6 +50,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          self.class.new(
+            elements: elements.transform_values(&block),
+            location: location
+          )
+        end
+
         def level
           [0] + level_of_children(elements.values)
         end

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

@@ -46,6 +46,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          Tuple.new(
+            types: types.map(&block),
+            location: location
+          )
+        end
+
         def level
           [0] + level_of_children(types)
         end

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

@@ -80,6 +80,13 @@ module Steep
           end
         end
 
+        def map_type(&block)
+          Union.build(
+            types: types.map(&block),
+            location: location
+          )
+        end
+
         include Helper::ChildrenLevel
 
         def level

data/lib/steep/drivers/stats.rb

@@ -83,7 +83,7 @@ module Steep
             end
           end
 
-          table = Terminal::Table.new(
+          table = Terminal::Table.new( # steep:ignore UnknownConstant
             headings: ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"],
             rows: rows
           )
@@ -166,7 +166,7 @@ module Steep
           {
             id: stats_id,
             method: "workspace/executeCommand",
-            params: { command: "steep/stats", arguments: [] }
+            params: { command: "steep/stats", arguments: _ = [] }
           })
 
         stats_response = wait_for_response_id(reader: client_reader, id: stats_id)

data/lib/steep/drivers/validate.rb

@@ -49,8 +49,10 @@ module Steep
             if buffer
               printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
               ds.each do |d|
-                printer.print(d)
-                stdout.puts
+                if d
+                  printer.print(_ = d)
+                  stdout.puts
+                end
               end
             end
           end

data/lib/steep/expectations.rb

@@ -23,7 +23,7 @@ module Steep
             :information
           when "HINT"
             :hint
-          end #: Diagnostic::LSPFormatter::severity
+          end #: Steep::Diagnostic::LSPFormatter::severity
 
         Diagnostic.new(
           start_position: start_position,
@@ -56,7 +56,7 @@ module Steep
             :hint
           else
             :error
-          end #: Diagnostic::LSPFormatter::severity
+          end #: Steep::Diagnostic::LSPFormatter::severity
 
         Diagnostic.new(
           start_position: start_position,

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
         )