steep 0.51.0 → 0.52.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 502d495f9b623c5d90a041a1e0bb7854be76251a8ac0f3567c1c91911eb641ee
-  data.tar.gz: 7845d6d26f38ceae87407d507f3f67b8d35bae18ecdd5f4ee9fdb841d434a4ad
+  metadata.gz: 3c9d5eb873780b31a2431d2e6c4efdc558fbb3a4a42c08cbe2580bb191db5bc8
+  data.tar.gz: dee794e9cb098309b9875396ed1dc9904a4c6882aeadb27c83c26604ebcbc87d
 SHA512:
-  metadata.gz: e2e61987da5ef5d78381affeb2f4fbb8b84dd2a6fede0baa60c68f54a3464e3cb7eea0e2822f22a66d62f1de3b9f8b223cd6399dceb927397a3dab0bed3fea5d
-  data.tar.gz: ee91ba6b1a4d8f35ec1fbc157efd2fb54f27b11e398af09a7ef3d4f403ae0ae2fab3258404316c6ded646f688b61ff38b47a514fec83cd9fe1b4fcf136fdc441
+  metadata.gz: ba05f88c28a78414ffcd41744558bdea978b72621f422571cb1450b7b0d56fb77c2b65329064226863db2517d4769a6f54e7c47ce92eef59d97f0403bb9e9425
+  data.tar.gz: 6e260b48940214b7c0910bf2678c587b469e163e70265f197ef8fd17a1703a68fd9488c77c3d1f8254939c074281717593e49812875fb705615189cd3ec4cdf0

data/.github/dependabot.yml

@@ -1,8 +1,15 @@
 version: 2
+
 updates:
-- package-ecosystem: bundler
-  directory: "/"
-  schedule:
-    interval: daily
-    time: "20:00"
-  open-pull-requests-limit: 10
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: daily
+      time: "20:00"
+    open-pull-requests-limit: 10
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every weekday
+      interval: "daily"

data/.github/workflows/ruby.yml

@@ -14,6 +14,7 @@ jobs:
         container_tag:
         - "2.7"
         - "3.0"
+        - "3.1"
         - "master-nightly-focal"
         task:
         - test
@@ -22,9 +23,10 @@ jobs:
     container:
       image: rubylang/ruby:${{ matrix.container_tag }}
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
     - name: Run test
       run: |
+        git config --global --add safe.directory /__w/steep/steep
         ruby -v
         gem install bundler
         bundle install --jobs 4 --retry 3

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## master
 
+## 0.52.2 (2022-05-02)
+
+* Handle class declaration with non-const super class ([\#546](https://github.com/soutaro/steep/pull/546))
+* Remove `#to_a` error message ([\#545](https://github.com/soutaro/steep/pull/545))
+* Add `#filter_map` shim ([\#544](https://github.com/soutaro/steep/pull/544))
+
+## 0.52.1 (2022-04-25)
+
+* Better union type inference (it type checks `Array#filter_map` now!) ([\#531](https://github.com/soutaro/steep/pull/531))
+* Improve method call hover message ([\#537](https://github.com/soutaro/steep/pull/537), [\#538](https://github.com/soutaro/steep/pull/538))
+* Make `NilClass#!` a special method to improve flow-sensitive typing ([\#539](https://github.com/soutaro/steep/pull/539))
+* Fix `steep binstub` ([\#540](https://github.com/soutaro/steep/pull/540), [\#541](https://github.com/soutaro/steep/pull/541))
+
+## 0.52.0 (2022-04-05)
+
+* Add `steep binstub` command ([\#527](https://github.com/soutaro/steep/pull/527))
+* Let hover and completion work in heredoc ([\#528](https://github.com/soutaro/steep/pull/528))
+* Better constant typing ([\#529](https://github.com/soutaro/steep/pull/529))
+
 ## 0.51.0 (2022-04-01)
 
 * Completion for constant ([\#524](https://github.com/soutaro/steep/pull/524))

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    steep (0.51.0)
+    steep (0.52.2)
       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 (>= 2.3.0)
+      rbs (>= 2.3.2)
       terminal-table (>= 2, < 4)
 
 PATH
@@ -24,7 +24,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.2.3)
+    activesupport (7.0.2.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -44,14 +44,14 @@ GEM
     minitest-slow_test (0.2.0)
       minitest (>= 5.0)
     parallel (1.22.1)
-    parser (3.1.1.0)
+    parser (3.1.2.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 (2.3.0)
+    rbs (2.3.2)
     stackprof (0.2.19)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)

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

@@ -431,7 +431,8 @@ module Steep
               case defined_in
               when RBS::BuiltinNames::BasicObject.name,
                 RBS::BuiltinNames::TrueClass.name,
-                RBS::BuiltinNames::FalseClass.name
+                RBS::BuiltinNames::FalseClass.name,
+                AST::Builtin::NilClass.module_name
                 return method_type.with(
                   type: method_type.type.with(
                     return_type: AST::Types::Logic::Not.new(location: method_type.type.return_type.location)

data/lib/steep/cli.rb

@@ -18,7 +18,7 @@ module Steep
     end
 
     def self.available_commands
-      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :stats]
+      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :stats, :binstub]
     end
 
     def process_global_options
@@ -208,6 +208,84 @@ module Steep
       end.run
     end
 
+    def process_binstub
+      path = Pathname("bin/steep")
+      root_path = Pathname.pwd
+      force = false
+
+      OptionParser.new do |opts|
+        opts.banner = <<BANNER
+Usage: steep binstub [options]
+
+Generate a binstub to execute Steep with setting up Bundler and rbenv/rvm.
+Use the executable for LSP integration setup.
+
+Options:
+BANNER
+        handle_logging_options opts
+
+        opts.on("-o PATH", "--output=PATH", "The path of the executable file (defaults to `bin/steep`)") do |v|
+          path = Pathname(v)
+        end
+
+        opts.on("--root=PATH", "The repository root path (defaults to `.`)") do |v|
+          root_path = (Pathname.pwd + v).cleanpath
+        end
+
+        opts.on("--[no-]force", "Overwrite file (defaults to false)") do
+          force = true
+        end
+      end.parse!(argv)
+
+      binstub_path = (Pathname.pwd + path).cleanpath
+      bindir_path = binstub_path.parent
+
+      bindir_path.mkpath
+
+      gemfile_path =
+        if defined?(Bundler)
+          Bundler.default_gemfile.relative_path_from(bindir_path)
+        else
+          Pathname("../Gemfile")
+        end
+
+      if binstub_path.file?
+        if force
+          stdout.puts Rainbow("#{path} already exists. Overwriting...").yellow
+        else
+          stdout.puts Rainbow(''"⚠️ #{path} already exists. Bye! 👋").red
+          return 0
+        end
+      end
+
+      template = <<TEMPLATE
+#!/usr/bin/env bash
+
+BINSTUB_DIR=$(cd $(dirname $0); pwd)
+GEMFILE=$(readlink -f ${BINSTUB_DIR}/#{gemfile_path})
+ROOT_DIR=$(readlink -f ${BINSTUB_DIR}/#{root_path.relative_path_from(bindir_path)})
+
+STEEP="bundle exec --gemfile=${GEMFILE} steep"
+
+if type "rbenv" > /dev/null 2>&1; then
+  STEEP="rbenv exec ${STEEP}"
+else
+  if type "rvm" > /dev/null 2>&1; then
+    STEEP="rvm ${ROOT_DIR} do ${STEEP}"
+  fi
+fi
+
+exec $STEEP $@
+TEMPLATE
+
+      binstub_path.write(template)
+      binstub_path.chmod(0755)
+
+      stdout.puts Rainbow("Successfully generated executable #{path} 🎉").blue
+
+      0
+    end
+
     def process_version
       stdout.puts Steep::VERSION
       0

data/lib/steep/server/interaction_worker.rb

@@ -78,8 +78,7 @@ module Steep
           Steep.measure "Generating hover response" do
             Steep.logger.info { "path=#{job.path}, line=#{job.line}, column=#{job.column}" }
 
-            hover = Services::HoverContent.new(service: service)
-            content = hover.content_for(path: job.path, line: job.line, column: job.column)
+            content = Services::HoverProvider.content_for(service: service, path: job.path, line: job.line, column: job.column)
             if content
               range = content.location.yield_self do |location|
                 lsp_range = location.as_lsp_range
@@ -89,7 +88,10 @@ module Steep
               end
 
               LSP::Interface::Hover.new(
-                contents: { kind: "markdown", value: format_hover(content)&.gsub(/<!--(?~-->)-->/, "") },
+                contents: {
+                  kind: "markdown",
+                  value: LSPFormatter.format_hover_content(content).to_s
+                },
                 range: range
               )
             end
@@ -100,101 +102,6 @@ module Steep
         end
       end
 
-      def format_hover(content)
-        case content
-        when Services::HoverContent::TypeAliasContent
-          comment = content.decl.comment&.string || ''
-
-          <<-MD
-#{comment}
-
-```rbs
-#{retrieve_decl_information(content.decl)}
-```
-          MD
-        when Services::HoverContent::InterfaceContent
-          comment = content.decl.comment&.string || ''
-
-          <<-MD
-#{comment}
-
-```rbs
-#{retrieve_decl_information(content.decl)}
-```
-          MD
-        when Services::HoverContent::ClassContent
-          comment = content.decl.comment&.string || ''
-
-          <<-MD
-#{comment}
-
-```rbs
-#{retrieve_decl_information(content.decl)}
-```
-          MD
-        when Services::HoverContent::VariableContent
-          "`#{content.name}`: `#{content.type.to_s}`"
-        when Services::HoverContent::MethodCallContent
-          method_name = case content.method_name
-                        when Services::HoverContent::InstanceMethodName
-                          "#{content.method_name.class_name}##{content.method_name.method_name}"
-                        when Services::HoverContent::SingletonMethodName
-                          "#{content.method_name.class_name}.#{content.method_name.method_name}"
-                        else
-                          nil
-                        end
-
-          if method_name
-            string = <<HOVER
-```
-#{method_name} ~> #{content.type}
-```
-HOVER
-            if content.definition
-              if content.definition.comments
-                string << "\n----\n\n#{content.definition.comments.map(&:string).join("\n\n")}"
-              end
-
-              string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
-            end
-          else
-            "`#{content.type}`"
-          end
-        when Services::HoverContent::DefinitionContent
-          string = <<HOVER
-```
-def #{content.method_name}: #{content.method_type}
-```
-HOVER
-          if (comment = content.comment_string)
-            string << "\n----\n\n#{comment}\n"
-          end
-
-          if content.definition.method_types.size > 1
-            string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
-          end
-
-          string
-        when Services::HoverContent::ConstantContent
-          ss = []
-          if content.class_or_module?
-            ss << ["```rbs", retrieve_decl_information(content.decl.primary.decl), "```"].join("\n")
-          end
-
-          if content.constant?
-            ss << ["```rbs", "#{content.full_name}: #{content.type}", "```"].join("\n")
-          end
-
-          if s = content.comment_string
-            ss << s
-          end
-
-          ss.join("\n\n----\n\n")
-        when Services::HoverContent::TypeContent
-          "`#{content.type}`"
-        end
-      end
-
       def process_completion(job)
         Steep.logger.tagged("#response_to_completion") do
           Steep.measure "Generating response" do
@@ -356,59 +263,6 @@ HOVER
         end
       end
 
-      def name_and_params(name, params)
-        if params.empty?
-          "#{name}"
-        else
-          ps = params.each.map do |param|
-            s = ""
-            if param.unchecked?
-              s << "unchecked "
-            end
-            case param.variance
-            when :invariant
-              # nop
-            when :covariant
-              s << "out "
-            when :contravariant
-              s << "in "
-            end
-            s + param.name.to_s
-          end
-
-          "#{name}[#{ps.join(", ")}]"
-        end
-      end
-
-      def name_and_args(name, args)
-        if name && args
-          if args.empty?
-            "#{name}"
-          else
-            "#{name}[#{args.join(", ")}]"
-          end
-        end
-      end
-
-      def retrieve_decl_information(decl)
-        case decl
-        when RBS::AST::Declarations::Class
-          super_class = if super_class = decl.super_class
-                          " < #{name_and_args(super_class.name, super_class.args)}"
-                        end
-          "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
-        when RBS::AST::Declarations::Module
-          self_type = unless decl.self_types.empty?
-                        " : #{decl.self_types.join(", ")}"
-                      end
-          "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
-        when RBS::AST::Declarations::Alias
-          "type #{decl.name} = #{decl.type}"
-        when RBS::AST::Declarations::Interface
-          "interface #{name_and_params(decl.name, decl.type_params)}"
-        end
-      end
-
       def format_completion_item(item)
         range = LanguageServer::Protocol::Interface::Range.new(
           start: LanguageServer::Protocol::Interface::Position.new(

data/lib/steep/server/lsp_formatter.rb

@@ -0,0 +1,234 @@
+module Steep
+  module Server
+    module LSPFormatter
+      include Services
+
+      class CommentBuilder
+        def initialize
+          @array = []
+        end
+
+        def self.build
+          builder = CommentBuilder.new
+          yield builder
+          builder.to_s
+        end
+
+        def to_s
+          unless @array.empty?
+            @array.join("\n\n----\n\n")
+          end
+        end
+
+        def <<(string)
+          if string
+            s = string.rstrip.gsub(/^[ \t]*<!--(?~-->)-->\n/, "").gsub(/\A([ \t]*\n)+/, "")
+            unless @array.include?(s)
+              @array << s
+            end
+          end
+        end
+
+        def push
+          s = ""
+          yield s
+          self << s
+        end
+      end
+
+      module_function
+
+      def format_hover_content(content)
+        case content
+        when HoverProvider::Ruby::VariableContent
+          "`#{content.name}`: `#{content.type.to_s}`"
+
+        when HoverProvider::Ruby::MethodCallContent
+          CommentBuilder.build do |builder|
+            call = content.method_call
+            builder.push do |s|
+              case call
+              when TypeInference::MethodCall::Typed
+                mt = call.actual_method_type.with(
+                  type: call.actual_method_type.type.with(return_type: call.return_type)
+                )
+                s << "```rbs\n#{mt.to_s}\n```\n\n"
+              when TypeInference::MethodCall::Error
+                s << "```rbs\n( ??? ) -> #{call.return_type.to_s}\n```\n\n"
+              end
+
+              s << to_list(call.method_decls) do |decl|
+                "`#{decl.method_name}`"
+              end
+            end
+
+            call.method_decls.each do |decl|
+              if comment = decl.method_def.comment
+                builder << <<EOM
+**#{decl.method_name.to_s}**
+
+```rbs
+#{decl.method_type}
+```
+
+#{decl.method_def.comment.string.gsub(/\A([ \t]*\n)+/, "")}
+EOM
+              end
+            end
+          end
+
+        when HoverProvider::Ruby::DefinitionContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```
+#{content.method_name}: #{content.method_type}
+```
+EOM
+            if comments = content.definition&.comments
+              comments.each do |comment|
+                builder << comment.string
+              end
+            end
+
+            if content.definition.method_types.size > 1
+              builder << to_list(content.definition.method_types) {|type| "`#{type.to_s}`" }
+            end
+          end
+        when HoverProvider::Ruby::ConstantContent
+          CommentBuilder.build do |builder|
+            if content.class_or_module?
+              builder << <<EOM
+```rbs
+#{declaration_summary(content.decl.primary.decl)}
+```
+EOM
+            end
+
+            if content.constant?
+              builder << <<EOM
+```rbs
+#{content.full_name}: #{content.type}
+```
+EOM
+            end
+
+            content.comments.each do |comment|
+              builder << comment.string
+            end
+          end
+        when HoverProvider::Ruby::TypeContent
+          "`#{content.type}`"
+        when HoverProvider::RBS::TypeAliasContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```rbs
+#{declaration_summary(content.decl)}
+```
+EOM
+            if comment = content.decl.comment
+              builder << comment.string
+            end
+          end
+        when HoverProvider::RBS::ClassContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```rbs
+#{declaration_summary(content.decl)}
+```
+EOM
+            if comment = content.decl.comment
+              builder << comment.string
+            end
+          end
+        when HoverProvider::RBS::InterfaceContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```rbs
+#{declaration_summary(content.decl)}
+```
+EOM
+            if comment = content.decl.comment
+              builder << comment.string
+            end
+          end
+        else
+          raise content.class.to_s
+        end
+      end
+
+      def to_list(collection, &block)
+        buffer = ""
+
+        strings =
+          if block
+            collection.map(&block)
+          else
+            collection.map(&:to_s)
+          end
+
+        strings.each do |s|
+          buffer << "- #{s}\n"
+        end
+
+        buffer
+      end
+
+      def name_and_args(name, args)
+        if args.empty?
+          "#{name}"
+        else
+          "#{name}[#{args.map(&:to_s).join(", ")}]"
+        end
+      end
+
+      def name_and_params(name, params)
+        if params.empty?
+          "#{name}"
+        else
+          ps = params.each.map do |param|
+            s = ""
+            if param.unchecked?
+              s << "unchecked "
+            end
+            case param.variance
+            when :invariant
+              # nop
+            when :covariant
+              s << "out "
+            when :contravariant
+              s << "in "
+            end
+            s << param.name.to_s
+
+            if param.upper_bound
+              s << " < #{param.upper_bound.to_s}"
+            end
+
+            s
+          end
+
+          "#{name}[#{ps.join(", ")}]"
+        end
+      end
+
+      def declaration_summary(decl)
+        case decl
+        when RBS::AST::Declarations::Class
+          super_class = if super_class = decl.super_class
+                          " < #{name_and_args(super_class.name, super_class.args)}"
+                        end
+          "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+        when RBS::AST::Declarations::Module
+          self_type = unless decl.self_types.empty?
+                        " : #{decl.self_types.map {|s| name_and_args(s.name, s.args) }.join(", ")}"
+                      end
+          "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+        when RBS::AST::Declarations::Alias
+          "type #{decl.name} = #{decl.type}"
+        when RBS::AST::Declarations::Interface
+          "interface #{name_and_params(decl.name, decl.type_params)}"
+        end
+      end
+    end
+  end
+end