steep 0.47.1 → 0.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f249f7e074584c271aace34633e7eebaf638c53faa821adc8ba20575c44781ac
-  data.tar.gz: 19630a5254b0b1d1a0f10dd2d2300111c47773ac5f615ccfe7d33f815edf38c2
+  metadata.gz: 72c3b61eccfe6a3f2cf2da22293bd7b50a001c25e82197b3efea52753857ff78
+  data.tar.gz: '08786e3140b0bbf10f79c5395a7026062abef6a690a9fefdf6ca464fbf13e92d'
 SHA512:
-  metadata.gz: d29cf28bca4f9235a7036e966edb7747872ebcd0a49bec3d6d21dcad73dc2f21cec05819b05b4df52b150bd24f998d533fd63b827f439462f3ce4b7173041ecd
-  data.tar.gz: 49f76f139a14b94449a19f1c26847b320fc104ce292eb6f9824bac58b99b0f7b1997c0daf405cb37e58a5ec42d011daa221431d0f7056a326dba5922a72f096e
+  metadata.gz: d3abc0d6f64deffebf187428be69cec72dc5c887e0ecb2fbc407c20e2dde66bae8ce3bdf5f7f8a43ccaa90c562fa9c178bb9cc93a3d3d5b7fa99d5e7344fbfdd
+  data.tar.gz: df16f83cf33224f0442124546d3406313dff27bd472fc60978864c40cdffcbb9aa8013bb049c940021ccb6e76c7a1338d9d30fc0fb07f71e306e7dae21885ad7

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## master
 
+## 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.48.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
@@ -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/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

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

@@ -21,17 +21,21 @@ module Steep
 
         alias eql? ==
 
-        def self.fresh(name)
+        def self.fresh_name(name)
           @mutex ||= Mutex.new
 
           @mutex.synchronize do
             @max ||= 0
             @max += 1
 
-            new(name: :"#{name}(#{@max})")
+            :"#{name}(#{@max})"
           end
         end
 
+        def self.fresh(name, location: nil)
+          new(name: fresh_name(name), location: location)
+        end
+
         def to_s
           name.to_s
         end
@@ -52,8 +56,15 @@ module Steep
           [0]
         end
 
+        def update(name: self.name, location: self.location)
+          self.class.new(
+            name: name,
+            location: location
+          )
+        end
+
         def with_location(new_location)
-          self.class.new(name: name, location: new_location)
+          update(location: new_location)
         end
       end
     end

data/lib/steep/diagnostic/ruby.rb

@@ -26,20 +26,32 @@ module Steep
       end
 
       module ResultPrinter
-        def print_result_to(io, level: 1)
-          printer = Drivers::TracePrinter.new(io)
-          printer.print result.trace, level: level
-        end
-
-        def trace_lines
-          StringIO.new.tap do |io|
-            print_result_to(io)
-          end.string.chomp
+        def relation_message(relation)
+          case
+          when relation.type?
+            relation.to_s
+          when relation.method?
+            if relation.super_type.is_a?(Interface::MethodType) && relation.sub_type.is_a?(Interface::MethodType)
+              relation.to_s
+            end
+          when relation.interface?
+            nil
+          when relation.block?
+            nil
+          when relation.function?
+            nil
+          when relation.params?
+            nil
+          end
         end
 
         def detail_lines
           StringIO.new.tap do |io|
-            print_result_to(io)
+            result.failure_path&.reverse_each.map do |result|
+              relation_message(result.relation)
+            end.compact.each.with_index(1) do |message, index|
+              io.puts "#{"  " * (index)}#{message}"
+            end
           end.string.chomp
         end
       end
@@ -440,7 +452,7 @@ module Steep
           super(node: node)
           @interface_method = interface_method
           @annotation_method = annotation_method
-          @result = result
+          @result = relation
         end
       end
 

data/lib/steep/diagnostic/signature.rb

@@ -101,6 +101,23 @@ module Steep
         end
       end
 
+      class UnsatisfiableTypeApplication < Base
+        attr_reader :type_name
+        attr_reader :type_arg
+        attr_reader :type_param
+
+        def initialize(type_name:, type_arg:, type_param:, location:)
+          super(location: location)
+          @type_name = type_name
+          @type_arg = type_arg
+          @type_param = type_param
+        end
+
+        def header_line
+          "Type application of `#{type_name}` doesn't satisfy the constraints: #{type_arg} <: #{type_param.upper_bound}"
+        end
+      end
+
       class InvalidMethodOverload < Base
         attr_reader :class_name
         attr_reader :method_name
@@ -307,6 +324,34 @@ module Steep
         end
       end
 
+      class RecursiveTypeAlias < Base
+        attr_reader :alias_names
+
+        def initialize(alias_names:, location:)
+          @alias_names = alias_names
+          super(location: location)
+        end
+
+        def header_line
+          "Type aliases cannot be *directly recursive*: #{alias_names.join(", ")}"
+        end
+      end
+
+      class NonregularTypeAlias < Base
+        attr_reader :type_name
+        attr_reader :nonregular_type
+
+        def initialize(type_name:, nonregular_type:, location:)
+          @type_name = type_name
+          @nonregular_type = nonregular_type
+          @location = location
+        end
+
+        def header_line
+          "Type alias #{type_name} is defined *non-regular*: #{nonregular_type}"
+        end
+      end
+
       def self.from_rbs_error(error, factory:)
         case error
         when RBS::ParsingError
@@ -388,6 +433,17 @@ module Steep
             type_name: error.type_name,
             member: error.member,
           )
+        when RBS::RecursiveTypeAliasError
+          Diagnostic::Signature::RecursiveTypeAlias.new(
+            alias_names: error.alias_names,
+            location: error.location
+          )
+        when RBS::NonregularTypeAliasError
+          Diagnostic::Signature::NonregularTypeAlias.new(
+            type_name: error.diagnostic.type_name,
+            nonregular_type: factory.type(error.diagnostic.nonregular_type),
+            location: error.location
+          )
         else
           raise error
         end