steep 0.47.0 → 0.49.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcd473b07b749d136220c73d4434747c909fc516b5d14332590a5e46abed65f9
-  data.tar.gz: c652c1608f635556d3c6704746c901b97047b5f2fc670ea563f50aa30d198210
+  metadata.gz: '0273968ec727f3b7c5c1007f9e27966c50ad7bc3128217a4ef30be4f97321037'
+  data.tar.gz: 195eb670673894e36af5e00ef911654f2a543c71e8de1d46c15e23035bef19c8
 SHA512:
-  metadata.gz: 9a540a74cb3d514500a5d57d7111ce45b16cafde7855aa182d0a6a188edf74d7203b17368cc275aa574aaa16f5a7f265eb0a95c1fa9c0a524e42fb78b67bffdc
-  data.tar.gz: eac07db23cad1f7eeb697d4f27e4548c45174e23d7552e7bd4246494efb25d8a967c10d6f00c112a1b3070b1a86e0131a4e3f0b95af8bf66f65747ba4e57f16b
+  metadata.gz: '0908edc4a3221256f450c9fd945d7127bd9ece3fa0359b7da88be8cebea30f7c766e023b84527e89e8f0c7956752310a3b0e98343b8c4808bfde518a89284456'
+  data.tar.gz: 4004adb0d0e8f2e0cd2629cd7e0c2bd6513a3a48bbd96d1d77621bbe0979b73686ab9c8ad718e3243081fdf492ff9728b5bf6df8e7357e1b1cf810393dad264c

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## master
 
+## 0.49.0 (2022-03-08)
+
+* Better typing for `#flat_map` ([\#504](https://github.com/soutaro/steep/pull/504))
+* Support lambdas (`->`) with block ([\#503](https://github.com/soutaro/steep/pull/503))
+* Let proc type be `::Proc` class instance ([\#502](https://github.com/soutaro/steep/pull/502))
+* Disable contextual typing on `bool` type ([\#501](https://github.com/soutaro/steep/pull/501))
+* Type check `return` without value ([\#500](https://github.com/soutaro/steep/pull/500))
+
+## 0.48.0 (2022-03-07)
+
+Steep supports all of the new features of RBS 2. 🎉
+It now requires RBS >= 2.2 and support all of the features.
+
+* Update RBS ([\#495](https://github.com/soutaro/steep/pull/495))
+* Support generic type aliases ([\#496](https://github.com/soutaro/steep/pull/496))
+* Support bounded generics ([\#499](https://github.com/soutaro/steep/pull/499))
+
+## 0.47.1 (2022-02-17)
+
+This update lets Steep run with Active Support 7.
+
+* Fix ActiveSupport requirement in `lib/steep.rb` ([#484](https://github.com/soutaro/steep/pull/484))
+
 ## 0.47.0 (2021-11-30)
 
 This update contains update for RBS 1.7.

data/Gemfile

@@ -7,6 +7,6 @@ gem "with_steep_types", path: "test/gems/with_steep_types"
 gem "without_steep_types", path: "test/gems/without_steep_types"
 
 gem "rake"
-gem "minitest", "~> 5.0"
+gem "minitest", "~> 5.15"
 gem "minitest-hooks"
 gem "stackprof"

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    steep (0.47.0)
+    steep (0.49.0)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
       parallel (>= 1.0.0)
       parser (>= 3.0)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (~> 1.7.0)
+      rbs (>= 2.2.0)
       terminal-table (>= 2, < 4)
 
 PATH
@@ -24,46 +24,44 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.4.1)
+    activesupport (7.0.2.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
     ast (2.4.2)
     concurrent-ruby (1.1.9)
-    ffi (1.15.4)
-    i18n (1.8.11)
+    ffi (1.15.5)
+    i18n (1.10.0)
       concurrent-ruby (~> 1.0)
     language_server-protocol (3.16.0.3)
-    listen (3.7.0)
+    listen (3.7.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    minitest (5.14.4)
+    minitest (5.15.0)
     minitest-hooks (1.5.0)
       minitest (> 5.3)
     parallel (1.21.0)
-    parser (3.0.3.1)
+    parser (3.1.1.0)
       ast (~> 2.4.1)
-    rainbow (3.0.0)
+    rainbow (3.1.1)
     rake (13.0.6)
-    rb-fsevent (0.11.0)
+    rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (1.7.1)
-    stackprof (0.2.17)
+    rbs (2.2.2)
+    stackprof (0.2.19)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.1.0)
-    zeitwerk (2.5.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  minitest (~> 5.0)
+  minitest (~> 5.15)
   minitest-hooks
   rake
   stackprof
@@ -72,4 +70,4 @@ DEPENDENCIES
   without_steep_types!
 
 BUNDLED WITH
-   2.2.27
+   2.3.8

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [1]
         end

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [2]
         end

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

@@ -30,6 +30,8 @@ module Steep
           @fvs = Set.new([self])
         end
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -21,143 +21,154 @@ module Steep
           @type_name_resolver ||= RBS::TypeNameResolver.from_env(definition_builder.env)
         end
 
+        def type_opt(type)
+          if type
+            type(type)
+          end
+        end
+
         def type(type)
           ty = type_cache[type] and return ty
 
-          type_cache[type] = case type
-          when RBS::Types::Bases::Any
-            Any.new(location: nil)
-          when RBS::Types::Bases::Class
-            Class.new(location: nil)
-          when RBS::Types::Bases::Instance
-            Instance.new(location: nil)
-          when RBS::Types::Bases::Self
-            Self.new(location: nil)
-          when RBS::Types::Bases::Top
-            Top.new(location: nil)
-          when RBS::Types::Bases::Bottom
-            Bot.new(location: nil)
-          when RBS::Types::Bases::Bool
-            Boolean.new(location: nil)
-          when RBS::Types::Bases::Void
-            Void.new(location: nil)
-          when RBS::Types::Bases::Nil
-            Nil.new(location: nil)
-          when RBS::Types::Variable
-            Var.new(name: type.name, location: nil)
-          when RBS::Types::ClassSingleton
-            type_name = type.name
-            Name::Singleton.new(name: type_name, location: nil)
-          when RBS::Types::ClassInstance
-            type_name = type.name
-            args = type.args.map {|arg| type(arg) }
-            Name::Instance.new(name: type_name, args: args, location: nil)
-          when RBS::Types::Interface
-            type_name = type.name
-            args = type.args.map {|arg| type(arg) }
-            Name::Interface.new(name: type_name, args: args, location: nil)
-          when RBS::Types::Alias
-            type_name = type.name
-            Name::Alias.new(name: type_name, args: [], location: nil)
-          when RBS::Types::Union
-            Union.build(types: type.types.map {|ty| type(ty) }, location: nil)
-          when RBS::Types::Intersection
-            Intersection.build(types: type.types.map {|ty| type(ty) }, location: nil)
-          when RBS::Types::Optional
-            Union.build(types: [type(type.type), Nil.new(location: nil)], location: nil)
-          when RBS::Types::Literal
-            Literal.new(value: type.literal, location: nil)
-          when RBS::Types::Tuple
-            Tuple.new(types: type.types.map {|ty| type(ty) }, location: nil)
-          when RBS::Types::Record
-            elements = type.fields.each.with_object({}) do |(key, value), hash|
-              hash[key] = type(value)
-            end
-            Record.new(elements: elements, location: nil)
-          when RBS::Types::Proc
-            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
+          type_cache[type] =
+            case type
+            when RBS::Types::Bases::Any
+              Any.new(location: type.location)
+            when RBS::Types::Bases::Class
+              Class.new(location: type.location)
+            when RBS::Types::Bases::Instance
+              Instance.new(location: type.location)
+            when RBS::Types::Bases::Self
+              Self.new(location: type.location)
+            when RBS::Types::Bases::Top
+              Top.new(location: type.location)
+            when RBS::Types::Bases::Bottom
+              Bot.new(location: type.location)
+            when RBS::Types::Bases::Bool
+              Boolean.new(location: type.location)
+            when RBS::Types::Bases::Void
+              Void.new(location: type.location)
+            when RBS::Types::Bases::Nil
+              Nil.new(location: type.location)
+            when RBS::Types::Variable
+              Var.new(name: type.name, location: type.location)
+            when RBS::Types::ClassSingleton
+              type_name = type.name
+              Name::Singleton.new(name: type_name, location: type.location)
+            when RBS::Types::ClassInstance
+              type_name = type.name
+              args = type.args.map {|arg| type(arg) }
+              Name::Instance.new(name: type_name, args: args, location: type.location)
+            when RBS::Types::Interface
+              type_name = type.name
+              args = type.args.map {|arg| type(arg) }
+              Name::Interface.new(name: type_name, args: args, location: type.location)
+            when RBS::Types::Alias
+              type_name = type.name
+              args = type.args.map {|arg| type(arg) }
+              Name::Alias.new(name: type_name, args: args, location: type.location)
+            when RBS::Types::Union
+              Union.build(types: type.types.map {|ty| type(ty) }, location: type.location)
+            when RBS::Types::Intersection
+              Intersection.build(types: type.types.map {|ty| type(ty) }, location: type.location)
+            when RBS::Types::Optional
+              Union.build(types: [type(type.type), Nil.new(location: nil)], location: type.location)
+            when RBS::Types::Literal
+              Literal.new(value: type.literal, location: type.location)
+            when RBS::Types::Tuple
+              Tuple.new(types: type.types.map {|ty| type(ty) }, location: type.location)
+            when RBS::Types::Record
+              elements = type.fields.each.with_object({}) do |(key, value), hash|
+                hash[key] = type(value)
+              end
+              Record.new(elements: elements, location: type.location)
+            when RBS::Types::Proc
+              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
+              Proc.new(type: func, block: block)
+            else
+              raise "Unexpected type given: #{type}"
+            end
         end
 
         def type_1(type)
           case type
           when Any
-            RBS::Types::Bases::Any.new(location: nil)
+            RBS::Types::Bases::Any.new(location: type.location)
           when Class
-            RBS::Types::Bases::Class.new(location: nil)
+            RBS::Types::Bases::Class.new(location: type.location)
           when Instance
-            RBS::Types::Bases::Instance.new(location: nil)
+            RBS::Types::Bases::Instance.new(location: type.location)
           when Self
-            RBS::Types::Bases::Self.new(location: nil)
+            RBS::Types::Bases::Self.new(location: type.location)
           when Top
-            RBS::Types::Bases::Top.new(location: nil)
+            RBS::Types::Bases::Top.new(location: type.location)
           when Bot
-            RBS::Types::Bases::Bottom.new(location: nil)
+            RBS::Types::Bases::Bottom.new(location: type.location)
           when Boolean
-            RBS::Types::Bases::Bool.new(location: nil)
+            RBS::Types::Bases::Bool.new(location: type.location)
           when Void
-            RBS::Types::Bases::Void.new(location: nil)
+            RBS::Types::Bases::Void.new(location: type.location)
           when Nil
-            RBS::Types::Bases::Nil.new(location: nil)
+            RBS::Types::Bases::Nil.new(location: type.location)
           when Var
-            RBS::Types::Variable.new(name: type.name, location: nil)
+            RBS::Types::Variable.new(name: type.name, location: type.location)
           when Name::Singleton
-            RBS::Types::ClassSingleton.new(name: type.name, location: nil)
+            RBS::Types::ClassSingleton.new(name: type.name, location: type.location)
           when Name::Instance
             RBS::Types::ClassInstance.new(
               name: type.name,
               args: type.args.map {|arg| type_1(arg) },
-              location: nil
+              location: type.location
             )
           when Name::Interface
             RBS::Types::Interface.new(
               name: type.name,
               args: type.args.map {|arg| type_1(arg) },
-              location: nil
+              location: type.location
             )
           when Name::Alias
-            type.args.empty? or raise "alias type with args is not supported"
-            RBS::Types::Alias.new(name: type.name, location: nil)
+            RBS::Types::Alias.new(
+              name: type.name,
+              args: type.args.map {|arg| type_1(arg) },
+              location: type.location
+            )
           when Union
             RBS::Types::Union.new(
               types: type.types.map {|ty| type_1(ty) },
-              location: nil
+              location: type.location
             )
           when Intersection
             RBS::Types::Intersection.new(
               types: type.types.map {|ty| type_1(ty) },
-              location: nil
+              location: type.location
             )
           when Literal
-            RBS::Types::Literal.new(literal: type.value, location: nil)
+            RBS::Types::Literal.new(literal: type.value, location: type.location)
           when Tuple
             RBS::Types::Tuple.new(
               types: type.types.map {|ty| type_1(ty) },
-              location: nil
+              location: type.location
             )
           when Record
             fields = type.elements.each.with_object({}) do |(key, value), hash|
               hash[key] = type_1(value)
             end
-            RBS::Types::Record.new(fields: fields, location: nil)
+            RBS::Types::Record.new(fields: fields, location: type.location)
           when Proc
             block = if type.block
                       RBS::Types::Block.new(
@@ -168,10 +179,10 @@ module Steep
             RBS::Types::Proc.new(
               type: function_1(type.type),
               block: block,
-              location: nil
+              location: type.location
             )
           when Logic::Base
-            RBS::Types::Bases::Bool.new(location: nil)
+            RBS::Types::Bases::Bool.new(location: type.location)
           else
             raise "Unexpected type given: #{type} (#{type.class})"
           end
@@ -204,45 +215,61 @@ module Steep
           )
         end
 
+        def type_param(type_param)
+          Interface::TypeParam.new(
+            name: type_param.name,
+            upper_bound: type_param.upper_bound&.yield_self {|u| type(u) },
+            variance: type_param.variance,
+            unchecked: type_param.unchecked?
+          )
+        end
+
+        def type_param_1(type_param)
+          RBS::AST::TypeParam.new(
+            name: type_param.name,
+            variance: type_param.variance,
+            upper_bound: type_param.upper_bound&.yield_self {|u| type_1(u) },
+            location: type_param.location
+          ).unchecked!(type_param.unchecked)
+        end
+
         def method_type(method_type, self_type:, subst2: nil, method_decls:)
           fvs = self_type.free_variables()
 
           type_params = []
-          alpha_vars = []
-          alpha_types = []
+          conflicting_names = []
 
-          method_type.type_params.map do |name|
-            if fvs.include?(name)
-              type = Types::Var.fresh(name)
-              alpha_vars << name
-              alpha_types << type
-              type_params << type.name
-            else
-              type_params << name
+          type_params = method_type.type_params.map do |type_param|
+            if fvs.include?(type_param.name)
+              conflicting_names << type_param.name
             end
+
+            type_param(type_param)
           end
-          subst = Interface::Substitution.build(alpha_vars, alpha_types)
+
+          type_params, subst = Interface::TypeParam.rename(type_params, conflicting_names)
           subst.merge!(subst2, overwrite: true) if subst2
 
-          type = Interface::MethodType.new(
-            type_params: type_params,
-            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: Interface::Function.new(
-                  params: params(block.type).subst(subst),
-                  return_type: type(block.type.return_type).subst(subst),
-                  location: nil
+          type =
+            Interface::MethodType.new(
+              type_params: type_params,
+              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: 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
-          )
+              end,
+              method_decls: method_decls
+            )
 
           if block_given?
             yield type
@@ -258,20 +285,14 @@ module Steep
           alpha_vars = []
           alpha_types = []
 
-          method_type.type_params.map do |name|
-            if fvs.include?(name)
-              type = RBS::Types::Variable.new(name: name, location: nil),
-              alpha_vars << name
-              alpha_types << type
-              type_params << type.name
-            else
-              type_params << name
-            end
+          conflicting_names = method_type.type_params.each.with_object([]) do |param, names|
+            names << params.name if fvs.include?(param.name)
           end
-          subst = Interface::Substitution.build(alpha_vars, alpha_types)
+
+          type_params, subst = Interface::TypeParam.rename(method_type.type_params, conflicting_names)
 
           type = RBS::MethodType.new(
-            type_params: type_params,
+            type_params: type_params.map {|param| type_param_1(param) },
             type: function_1(method_type.type.subst(subst)),
             block: method_type.block&.yield_self do |block|
               block_type = block.type.subst(subst)
@@ -300,16 +321,19 @@ module Steep
           end
         end
 
-        def unfold(type_name)
-          type_name.yield_self do |type_name|
-            type(definition_builder.expand_alias(type_name))
-          end
+        def unfold(type_name, args)
+          type(
+            definition_builder.expand_alias2(
+              type_name,
+              args.empty? ? args : args.map {|t| type_1(t) }
+            )
+          )
         end
 
         def expand_alias(type)
           unfolded = case type
                      when AST::Types::Name::Alias
-                       unfold(type.name)
+                       unfold(type.name, type.args)
                      else
                        type
                      end
@@ -369,7 +393,7 @@ module Steep
           when AST::Types::Name::Alias
             unwrap_optional(expand_alias(type))
           when AST::Types::Boolean
-            [AST::Builtin.true_type, AST::Builtin.false_type]
+            [type, type]
           else
             [type, nil]
           end

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

@@ -21,6 +21,14 @@ module Steep
             @fvs ||= Set.new
           end
         end
+
+        module NoChild
+          def each_child(&block)
+            unless block
+              enum_for :each_child
+            end
+          end
+        end
       end
     end
   end

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

@@ -26,6 +26,8 @@ module Steep
           @fvs = Set.new([self])
         end
 
+        include Helper::NoChild
+
         def to_s
           "instance"
         end

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

@@ -72,6 +72,10 @@ module Steep
 
         include Helper::ChildrenLevel
 
+        def each_child(&block)
+          types.each(&block)
+        end
+
         def level
           [0] + level_of_children(types)
         end

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

@@ -31,6 +31,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -13,6 +13,8 @@ module Steep
             @fvs ||= Set[]
           end
 
+          include Helper::NoChild
+
           def hash
             self.class.hash
           end

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

@@ -72,6 +72,10 @@ module Steep
             end
           end
 
+          def each_child(&block)
+            args.each(&block)
+          end
+
           include Helper::ChildrenLevel
 
           def level
@@ -98,6 +102,8 @@ module Steep
           def with_location(new_location)
             self.class.new(name: name, location: new_location)
           end
+
+          include Helper::NoChild
         end
 
         class Instance < Applying