steep 0.52.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c9d5eb873780b31a2431d2e6c4efdc558fbb3a4a42c08cbe2580bb191db5bc8
-  data.tar.gz: dee794e9cb098309b9875396ed1dc9904a4c6882aeadb27c83c26604ebcbc87d
+  metadata.gz: 899bca0fd211114d52e015acc844ee4648eadb6b739af911f7ac73560cedef83
+  data.tar.gz: 2fe5b52342a6b932d5ce08f5b78c417e43cda38db378c35d1b31891ca7c79465
 SHA512:
-  metadata.gz: ba05f88c28a78414ffcd41744558bdea978b72621f422571cb1450b7b0d56fb77c2b65329064226863db2517d4769a6f54e7c47ce92eef59d97f0403bb9e9425
-  data.tar.gz: 6e260b48940214b7c0910bf2678c587b469e163e70265f197ef8fd17a1703a68fd9488c77c3d1f8254939c074281717593e49812875fb705615189cd3ec4cdf0
+  metadata.gz: 20e09462ddef35a3aa00a19d6f7cb86f2862c9ab700131bf439fc7750b088d43d1f2bb3380dfdf57a0c881d58c885b789d47eba35d7e146156809511e4e1c64c
+  data.tar.gz: dfa20a13b3b25575419ad1c9ac2417b1b873a0732eded5fa643e6e5768b644e27ea07c8d83bf9ae5e333b872d8f039aba111bee4d7ae2a48034dc06047265fee

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 1.0.0 (2022-05-20)
+
+* Add special typing rule for `Array#compact` ([\#555](https://github.com/soutaro/steep/pull/555))
+* Add custom method type of `#fetch` on tuples and records ([\#554](https://github.com/soutaro/steep/pull/554))
+* Better `masgn` ([\#553](https://github.com/soutaro/steep/pull/553))
+* Fix method parameter type checking ([\#552](https://github.com/soutaro/steep/pull/552))
+
 ## 0.52.2 (2022-05-02)
 
 * Handle class declaration with non-const super class ([\#546](https://github.com/soutaro/steep/pull/546))

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (0.52.2)
+    steep (1.0.0)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
@@ -24,7 +24,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.2.4)
+    activesupport (7.0.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -51,7 +51,7 @@ GEM
     rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (2.3.2)
+    rbs (2.4.0)
     stackprof (0.2.19)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)

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

@@ -674,6 +674,57 @@ module Steep
                   )
                 end
 
+                array_interface.methods[:fetch] = array_interface.methods[:fetch].yield_self do |fetch|
+                  Interface::Interface::Entry.new(
+                    method_types: type.types.flat_map.with_index {|elem_type, index|
+                      [
+                        Interface::MethodType.new(
+                          type_params: [],
+                          type: Interface::Function.new(
+                            params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
+                            return_type: elem_type,
+                            location: nil
+                          ),
+                          block: nil,
+                          method_decls: Set[]
+                        ),
+                        Interface::MethodType.new(
+                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                          type: Interface::Function.new(
+                            params: Interface::Function::Params.build(
+                              required: [
+                                AST::Types::Literal.new(value: index),
+                                AST::Types::Var.new(name: :T)
+                              ]
+                            ),
+                            return_type: AST::Types::Union.build(types: [elem_type, AST::Types::Var.new(name: :T)]),
+                            location: nil
+                          ),
+                          block: nil,
+                          method_decls: Set[]
+                        ),
+                        Interface::MethodType.new(
+                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                          type: Interface::Function.new(
+                            params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
+                            return_type: AST::Types::Union.build(types: [elem_type, AST::Types::Var.new(name: :T)]),
+                            location: nil
+                          ),
+                          block: Interface::Block.new(
+                            type: Interface::Function.new(
+                              params: Interface::Function::Params.build(required: [AST::Builtin::Integer.instance_type]),
+                              return_type: AST::Types::Var.new(name: :T),
+                              location: nil
+                            ),
+                            optional: false
+                          ),
+                          method_decls: Set[]
+                        )
+                      ]
+                    } + fetch.method_types
+                  )
+                end
+
                 array_interface.methods[:first] = array_interface.methods[:first].yield_self do |first|
                   Interface::Interface::Entry.new(
                     method_types: [
@@ -712,11 +763,11 @@ module Steep
 
           when Record
             yield_self do
-              key_type = type.elements.keys.map {|value| Literal.new(value: value, location: nil) }.yield_self do |types|
+              all_key_type = type.elements.keys.map {|value| Literal.new(value: value, location: nil) }.yield_self do |types|
                 Union.build(types: types, location: nil)
               end
-              value_type = Union.build(types: type.elements.values, location: nil)
-              hash_type = Builtin::Hash.instance_type(key_type, value_type)
+              all_value_type = Union.build(types: type.elements.values, location: nil)
+              hash_type = Builtin::Hash.instance_type(all_key_type, all_value_type)
 
               interface(hash_type, private: private, self_type: self_type).tap do |hash_interface|
                 hash_interface.methods[:[]] = hash_interface.methods[:[]].yield_self do |ref|
@@ -768,6 +819,54 @@ module Steep
                     } + update.method_types
                   )
                 end
+
+                hash_interface.methods[:fetch] = hash_interface.methods[:fetch].yield_self do |update|
+                  Interface::Interface::Entry.new(
+                    method_types: type.elements.flat_map {|key_value, value_type|
+                      key_type = Literal.new(value: key_value, location: nil)
+
+                      [
+                        Interface::MethodType.new(
+                          type_params: [],
+                          type: Interface::Function.new(
+                            params: Interface::Function::Params.build(required: [key_type]),
+                            return_type: value_type,
+                            location: nil
+                          ),
+                          block: nil,
+                          method_decls: Set[]
+                        ),
+                        Interface::MethodType.new(
+                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                          type: Interface::Function.new(
+                            params: Interface::Function::Params.build(required: [key_type, AST::Types::Var.new(name: :T)]),
+                            return_type: AST::Types::Union.build(types: [value_type, AST::Types::Var.new(name: :T)]),
+                            location: nil
+                          ),
+                          block: nil,
+                          method_decls: Set[]
+                        ),
+                        Interface::MethodType.new(
+                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                          type: Interface::Function.new(
+                            params: Interface::Function::Params.build(required: [key_type]),
+                            return_type: AST::Types::Union.build(types: [value_type, AST::Types::Var.new(name: :T)]),
+                            location: nil
+                          ),
+                          block: Interface::Block.new(
+                            type: Interface::Function.new(
+                              params: Interface::Function::Params.build(required: [all_key_type]),
+                              return_type: AST::Types::Var.new(name: :T),
+                              location: nil
+                            ),
+                            optional: false
+                          ),
+                          method_decls: Set[]
+                        )
+                      ]
+                    } + update.method_types
+                  )
+                end
               end
             end
 

data/lib/steep/server/lsp_formatter.rb

@@ -48,6 +48,18 @@ module Steep
             call = content.method_call
             builder.push do |s|
               case call
+              when TypeInference::MethodCall::Special
+                mt = call.actual_method_type.with(
+                  type: call.actual_method_type.type.with(return_type: call.return_type)
+                )
+                s << <<-EOM
+**💡 Custom typing rule applies**
+
+```rbs
+#{mt.to_s}
+```
+
+                EOM
               when TypeInference::MethodCall::Typed
                 mt = call.actual_method_type.with(
                   type: call.actual_method_type.type.with(return_type: call.return_type)

data/lib/steep/source.rb

@@ -406,8 +406,8 @@ module Steep
         Source.construct_mapping(node: node_, annotations: annotations, mapping: mapping)
 
         annotations.each do |annot|
-          mapping[node] ||= []
-          mapping[node] << annot
+          mapping[node_] ||= []
+          mapping[node_] << annot
         end
 
         Source.new(path: path, node: node_, mapping: mapping)

data/lib/steep/type_construction.rb

@@ -2662,11 +2662,13 @@ module Steep
           when :ivasgn
             _, constr = constr.ivasgn(assignment, element_type)
           when :splat
-            case assignment.children[0].type
+            case assignment.children[0]&.type
             when :lvasgn
               _, constr = constr.lvasgn(assignment.children[0], unwrap_rhs_type)
             when :ivasgn
               _, constr = constr.ivasgn(assignment.children[0], unwrap_rhs_type)
+            when nil
+              # foo, * = bar
             else
               raise
             end
@@ -2684,7 +2686,31 @@ module Steep
         unless rhs_type.is_a?(AST::Types::Any)
           Steep.logger.error("Unsupported masgn rhs type: array or tuple is supported (#{rhs_type})")
         end
-        _, constr = constr.fallback_to_any(lhs)
+
+        untyped = AST::Builtin.any_type
+
+        constr = lhs.children.inject(constr) do |constr, assignment|
+          case assignment.type
+          when :lvasgn
+            _, constr = constr.lvasgn(assignment, untyped)
+          when :ivasgn
+            _, constr = constr.ivasgn(assignment, untyped)
+          when :splat
+            case assignment.children[0]&.type
+            when :lvasgn
+              _, constr = constr.lvasgn(assignment.children[0], untyped)
+            when :ivasgn
+              _, constr = constr.ivasgn(assignment.children[0], untyped)
+            when nil
+              # foo, * = bar
+            else
+              raise
+            end
+          end
+
+          constr
+        end
+
         add_typing(node, type: rhs_type, constr: constr)
       end
     end
@@ -3114,13 +3140,61 @@ module Steep
       end
     end
 
+    SPECIAL_METHOD_NAMES = {
+      array_compact: Set[
+        MethodName("::Array#compact"),
+        MethodName("::Enumerable#compact")
+      ]
+    }
+
+    def try_special_method(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:)
+      decls = method_type.method_decls
+
+      case
+      when decl = decls.find {|decl| SPECIAL_METHOD_NAMES[:array_compact].include?(decl.method_name) }
+        if arguments.empty? && !block_params
+          # compact
+          return_type = method_type.type.return_type
+          if AST::Builtin::Array.instance_type?(return_type)
+            elem = return_type.args[0]
+            type = AST::Builtin::Array.instance_type(unwrap(elem))
+
+            _, constr = add_typing(node, type: type)
+            call = TypeInference::MethodCall::Special.new(
+              node: node,
+              context: constr.context.method_context,
+              method_name: decl.method_name,
+              receiver_type: receiver_type,
+              actual_method_type: method_type.with(type: method_type.type.with(return_type: type)),
+              return_type: type,
+              method_decls: decls
+            )
+
+            return [call, constr]
+          end
+        end
+      end
+
+      nil
+    end
+
     def type_method_call(node, method_name:, receiver_type:, method:, arguments:, block_params:, block_body:, topdown_hint:)
       node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
       results = method.method_types.map do |method_type|
         Steep.logger.tagged method_type.to_s do
           typing.new_child(node_range) do |child_typing|
-            self.with_new_typing(child_typing).try_method_type(
+            constr = self.with_new_typing(child_typing)
+
+            constr.try_special_method(
+              node,
+              receiver_type: receiver_type,
+              method_name: method_name,
+              method_type: method_type,
+              arguments: arguments,
+              block_params: block_params,
+              block_body: block_body
+            ) || constr.try_method_type(
               node,
               receiver_type: receiver_type,
               method_name: method_name,

data/lib/steep/type_inference/method_call.rb

@@ -79,13 +79,16 @@ module Steep
         attr_reader :actual_method_type
         attr_reader :method_decls
 
-        def initialize(node:, context:, method_name:, receiver_type:, actual_method_type:, method_decls:, return_type: actual_method_type.return_type)
+        def initialize(node:, context:, method_name:, receiver_type:, actual_method_type:, method_decls:, return_type:)
           super(node: node, context: context, method_name: method_name, receiver_type: receiver_type, return_type: return_type)
           @actual_method_type = actual_method_type
           @method_decls = method_decls
         end
       end
 
+      class Special < Typed
+      end
+
       class Untyped < Base
         def initialize(node:, context:, method_name:)
           super(node: node, context: context, method_name: method_name, receiver_type: AST::Types::Any.new, return_type: AST::Types::Any.new)

data/lib/steep/type_inference/method_params.rb

@@ -315,6 +315,7 @@ module Steep
             when Interface::Function::Params::PositionalParams::Rest
               rest_types << param.type
               positional_params = nil
+              args.shift
               break
             when nil
               has_error = true

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.52.2"
+  VERSION = "1.0.0"
 end

data/smoke/compact/Steepfile

@@ -0,0 +1,6 @@
+target :test do
+  check "*.rb"
+  signature "*.rbs"
+
+  configure_code_diagnostics(Steep::Diagnostic::Ruby.all_error)
+end

data/smoke/compact/a.rb

@@ -0,0 +1,2 @@
+# @type var a: Array[Integer | bool]
+a = [1, nil, true].compact

data/smoke/compact/a.rbs

@@ -0,0 +1,5 @@
+module Compact
+  class Foo
+    def compact: () -> Array[String | bool | nil]
+  end
+end

data/smoke/compact/b.rb

@@ -0,0 +1,2 @@
+# @type var y: Array[String | bool]
+y = Compact::Foo.new.compact

data/smoke/compact/test_expectations.yml

@@ -0,0 +1,18 @@
+---
+- file: b.rb
+  diagnostics:
+  - range:
+      start:
+        line: 2
+        character: 0
+      end:
+        line: 2
+        character: 28
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Array[(::String | bool | nil)]` to a variable of type `::Array[(::String | bool)]`
+        ::Array[(::String | bool | nil)] <: ::Array[(::String | bool)]
+          (::String | bool | nil) <: (::String | bool)
+            nil <: (::String | bool)
+              nil <: ::String
+    code: Ruby::IncompatibleAssignment

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.52.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-02 00:00:00.000000000 Z
+date: 2022-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -315,6 +315,11 @@ files:
 - smoke/class/i.rb
 - smoke/class/i.rbs
 - smoke/class/test_expectations.yml
+- smoke/compact/Steepfile
+- smoke/compact/a.rb
+- smoke/compact/a.rbs
+- smoke/compact/b.rb
+- smoke/compact/test_expectations.yml
 - smoke/const/Steepfile
 - smoke/const/a.rb
 - smoke/const/b.rb