steep 0.46.0 → 0.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e43c16938ef0238a9b3e44934a3e183ec663722b4c1161f9bd016dfcd2442b9b
-  data.tar.gz: 20168ebc69417b83c9eff010d44aac53ac43f47c572c8acc99d52d08ec11866d
+  metadata.gz: 72c3b61eccfe6a3f2cf2da22293bd7b50a001c25e82197b3efea52753857ff78
+  data.tar.gz: '08786e3140b0bbf10f79c5395a7026062abef6a690a9fefdf6ca464fbf13e92d'
 SHA512:
-  metadata.gz: 33c2bd116ea87f549ffb29fbc2382e7c000405a74280fcc4a1a8553ae52e6b7af3d5611a150c828d494fe50f37e120e58e45f286bd374bbd35958ee0c760c872
-  data.tar.gz: 0466f3f59d18bf0ba34ce522bc6a1cceed85c1f6ca4df66b6647a557bec165c64dd9d594f673833dc24a0b5a9d0eb04795bff37dc391e22cf560b566c6f08319
+  metadata.gz: d3abc0d6f64deffebf187428be69cec72dc5c887e0ecb2fbc407c20e2dde66bae8ce3bdf5f7f8a43ccaa90c562fa9c178bb9cc93a3d3d5b7fa99d5e7344fbfdd
+  data.tar.gz: df16f83cf33224f0442124546d3406313dff27bd472fc60978864c40cdffcbb9aa8013bb049c940021ccb6e76c7a1338d9d30fc0fb07f71e306e7dae21885ad7

data/.github/workflows/ruby.yml

@@ -12,7 +12,6 @@ jobs:
     strategy:
       matrix:
         container_tag:
-        - "2.6"
         - "2.7"
         - "3.0"
         - "master-nightly-focal"

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## 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.
+
+* 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.
+
+* RBS 1.7 ([#455](https://github.com/soutaro/steep/pull/455))
+* Bug fixes related to `SendArgs` ([#444](https://github.com/soutaro/steep/pull/444), [#449](https://github.com/soutaro/steep/pull/449), [#451](https://github.com/soutaro/steep/pull/451))
+* LSP completion item formatting improvement ([#442](https://github.com/soutaro/steep/pull/442))
+
 ## 0.46.0 (2021-08-30)
 
 This release updates Steepfile DSL syntax, introducing `stdlib_path` and `configure_code_diagnostics` syntax (methods).

data/Gemfile

@@ -7,7 +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 "racc", "~> 1.4"
+gem "minitest", "~> 5.15"
 gem "minitest-hooks"
 gem "stackprof"

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    steep (0.46.0)
+    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.2.0)
+      rbs (>= 2.2.0)
       terminal-table (>= 2, < 4)
 
 PATH
@@ -24,49 +24,45 @@ 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.3)
-    i18n (1.8.10)
+    ffi (1.15.5)
+    i18n (1.10.0)
       concurrent-ruby (~> 1.0)
-    language_server-protocol (3.16.0.2)
-    listen (3.7.0)
+    language_server-protocol (3.16.0.3)
+    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.20.1)
-    parser (3.0.2.0)
+    parallel (1.21.0)
+    parser (3.1.1.0)
       ast (~> 2.4.1)
-    racc (1.5.2)
-    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.5.1)
-    stackprof (0.2.17)
-    terminal-table (3.0.1)
+    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.0.0)
-    zeitwerk (2.4.2)
+    unicode-display_width (2.1.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  minitest (~> 5.0)
+  minitest (~> 5.15)
   minitest-hooks
-  racc (~> 1.4)
   rake
   stackprof
   steep!
@@ -74,4 +70,4 @@ DEPENDENCIES
   without_steep_types!
 
 BUNDLED WITH
-   2.2.22
+   2.3.8

data/README.md

@@ -8,7 +8,7 @@ Install via RubyGems.
 
 ### Requirements
 
-Steep requires Ruby 2.6.
+Steep requires Ruby 2.6 or later.
 
 ## Usage
 
@@ -126,6 +126,7 @@ end
 
 class Phone
   # @dynamic country, number
+  attr_reader :country, :number
 
   def initialize(country:, number:)
     @country = country

data/lib/steep/annotation_parser.rb

@@ -25,7 +25,7 @@ module Steep
         @location = location
 
         message = case exn
-                  when RBS::Parser::SyntaxError
+                  when RBS::ParsingError
                     Diagnostic::Signature::SyntaxError.parser_syntax_error_message(exn)
                   else
                     exn.message

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