steep 0.47.1 → 0.49.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f249f7e074584c271aace34633e7eebaf638c53faa821adc8ba20575c44781ac
-  data.tar.gz: 19630a5254b0b1d1a0f10dd2d2300111c47773ac5f615ccfe7d33f815edf38c2
+  metadata.gz: 44df04a21f7dc9d7514ad6acb34549f40fe0b4d962840c29ced4ceca926fd000
+  data.tar.gz: 15ac298575e8af8d29c1b1ab5e2894f3e62677dedd58b166d147d3d1649026d3
 SHA512:
-  metadata.gz: d29cf28bca4f9235a7036e966edb7747872ebcd0a49bec3d6d21dcad73dc2f21cec05819b05b4df52b150bd24f998d533fd63b827f439462f3ce4b7173041ecd
-  data.tar.gz: 49f76f139a14b94449a19f1c26847b320fc104ce292eb6f9824bac58b99b0f7b1997c0daf405cb37e58a5ec42d011daa221431d0f7056a326dba5922a72f096e
+  metadata.gz: cdc1e1dea1ef2aa9cebd6d40a850894340e2d0ed26f8a982c81c80d384522712c442a499ef12419b0b224cd1bb659944198b8dc897eea692e4d6c06284c86381
+  data.tar.gz: 22a8d55bd324e3527ffd2a8886bbf7fe28e766ab2dab1e175c43a08b37d256c647f39a05e7890ed5b2726934428bb303c1fe98c45ad07166df2fb2698cc835af

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## master
 
+## 0.49.1 (2022-03-11)
+
+* Fix lambda typing ([\#506](https://github.com/soutaro/steep/pull/506))
+* Validate type descendants ([\#507](https://github.com/soutaro/steep/pull/507))
+* Fix print error with absolute path ([\#508](https://github.com/soutaro/steep/pull/508))
+* Skip non-target ruby code on `steep stats` ([\#509](https://github.com/soutaro/steep/pull/509))
+
+## 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.

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    steep (0.47.1)
+    steep (0.49.1)
       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,7 +24,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.2.2)
+    activesupport (7.0.2.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -42,15 +42,15 @@ GEM
     minitest-hooks (1.5.0)
       minitest (> 5.3)
     parallel (1.21.0)
-    parser (3.1.0.0)
+    parser (3.1.1.0)
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
     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)
@@ -70,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

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

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

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

@@ -90,6 +90,15 @@ module Steep
         def block_required?
           block && !block.optional?
         end
+
+        def each_child(&block)
+          if block_given?
+            type.each_child(&block)
+            self.block&.type&.each_child(&block)
+          else
+            enum_for :each_child
+          end
+        end
       end
     end
   end

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

@@ -42,6 +42,10 @@ module Steep
 
         include Helper::ChildrenLevel
 
+        def each_child(&block)
+          elements.each_value(&block)
+        end
+
         def level
           [0] + level_of_children(elements.values)
         end