steep 1.7.0.dev.3 → 1.7.0

data/lib/steep/rake_task.rb

@@ -0,0 +1,132 @@
+require "rake"
+require "rake/tasklib"
+require "steep/cli"
+
+module Steep
+  # Provides Rake tasks for running Steep commands.
+  #
+  # require "steep/rake_task"
+  # Steep::RakeTask.new do |t|
+  #   t.check.severity_level = :error
+  #   t.watch.verbose
+  #   t.stats << "--format=table"
+  # end
+  class RakeTask < Rake::TaskLib # steep:ignore UnknownConstant
+    attr_accessor :name
+
+    def self.available_commands
+      %i(init check stats binstub project watch)
+    end
+
+    def initialize(name = :steep, cli_runner = default_cli_runner)
+      super()
+
+      @name = name
+
+      configuration = TaskConfiguration.new
+
+      yield configuration if block_given?
+
+      define_tasks(configuration, cli_runner)
+    end
+
+    private
+
+    # :nodoc:
+    class TaskConfiguration
+      def initialize
+        @commands = {}
+      end
+
+      def method_missing(command)
+        if respond_to?(command)
+          @commands[command] ||= CommandConfiguration.new
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        RakeTask.available_commands.include?(name) || super
+      end
+
+      def options(command)
+        @commands[command]&.to_a || []
+      end
+    end
+
+    # :nodoc:
+    class CommandConfiguration
+      def initialize
+        @options = []
+      end
+
+      def method_missing(name, value = nil)
+        option = "--#{name.to_s.gsub(/_/, '-').gsub(/=/, '')}"
+        option << "=#{value}" if value
+
+        self << option
+      end
+
+      def respond_to_missing?(_name)
+        true
+      end
+
+      def <<(value)
+        @options << value
+        self
+      end
+
+      def to_a
+        @options
+      end
+    end
+
+    def default_cli_runner
+      lambda do |arguments|
+        require "steep"
+
+        cli = Steep::CLI.new(
+          stdout: $stdout,
+          stdin: $stdin,
+          stderr: $stderr,
+          argv: arguments
+        )
+
+        cli.run
+      end
+    end
+
+    def define_tasks(configuration, cli_runner)
+      namespace name do
+        RakeTask.available_commands.each do |command|
+          desc "Run steep #{command}"
+          task command do |_, args|
+            configured_options = configuration.options(command)
+
+            argv = [
+              command.to_s,
+              *configured_options,
+              *args.extras
+            ]
+
+            result = cli_runner[argv]
+
+            raise "Steep failed" if result.nonzero?
+          end
+        end
+
+        desc "Run steep help"
+        task "help" do
+          arguments = ["--help"]
+
+          cli_runner[arguments]
+        end
+      end
+
+      # Default steep task to steep:check
+      desc "Run steep check" unless ::Rake.application.last_description # steep:ignore UnknownConstant
+      task name => ["#{name}:check"]
+    end
+  end
+end

data/lib/steep/server/interaction_worker.rb

@@ -90,6 +90,12 @@ module Steep
           collect_changes(request)
           queue_job ApplyChangeJob.new
 
+        when "$/file/reset"
+          uri = request[:params][:uri]
+          text = request[:params][:content]
+          reset_change(uri: uri, text: text)
+          queue_job ApplyChangeJob.new
+
         when "textDocument/hover"
           id = request[:id]
 

data/lib/steep/server/lsp_formatter.rb

@@ -263,6 +263,8 @@ module Steep
           <<~MD
             **Keyword argument**: `#{item.identifier}`
           MD
+        else
+          raise
         end
       end
 

data/lib/steep/services/completion_provider.rb

@@ -740,7 +740,7 @@ module Steep
             if method = shape.methods[call.method_name]
               method.method_types.each.with_index do |method_type, i|
                 defn = method_type.method_decls.to_a[0]&.method_def
-                if defn
+                if defn && defn.type.type
                   range = range_for(position, prefix: prefix)
                   kwargs = argument_nodes.find { |arg| arg.type == :kwargs }&.children || []
                   used_kwargs = kwargs.filter_map { |arg| arg.type == :pair && arg.children.first.children.first }

data/lib/steep/services/file_loader.rb

@@ -12,30 +12,25 @@ module Steep
           pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
 
           pats.each do |path|
-            absolute_path = base_dir + path
-
-            if absolute_path.file?
-              relative_path = absolute_path.relative_path_from(base_dir)
-              if pattern =~ relative_path
-                yield relative_path
-              end
-            else
-              files = if absolute_path.directory?
-                        Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
-                      else
-                        Pathname.glob(absolute_path.to_s)
-                      end
-
-              files.sort.each do |source_path|
-                if source_path.file?
-                  relative_path = source_path.relative_path_from(base_dir)
-                  unless pattern.ignore?(relative_path)
-                    yield relative_path
+            Pathname.glob((base_dir + path).to_s).each do |absolute_path|
+              if absolute_path.file?
+                relative_path = absolute_path.relative_path_from(base_dir)
+                if pattern =~ relative_path
+                  yield relative_path
+                end
+              else
+                files = Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+
+                files.sort.each do |source_path|
+                  if source_path.file?
+                    relative_path = source_path.relative_path_from(base_dir)
+                    unless pattern.ignore?(relative_path)
+                      yield relative_path
+                    end
                   end
                 end
               end
             end
-
           end
         else
           enum_for :each_path_in_patterns, pattern, commandline_patterns

data/lib/steep/services/signature_help_provider.rb

@@ -7,15 +7,17 @@ module Steep
         # @implements Item
 
         def parameters
-          arguments = [] #: Array[String]
-          arguments.push(*method_type.type.required_positionals.map(&:to_s))
-          arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
-          arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
-          arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
-          arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
-          arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
-          arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
-          arguments
+          if method_type.type.is_a?(RBS::Types::Function)
+            arguments = [] #: Array[String]
+            arguments.push(*method_type.type.required_positionals.map(&:to_s))
+            arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
+            arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
+            arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
+            arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
+            arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
+            arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
+            arguments
+          end
         end
       end
 

data/lib/steep/signature/validator.rb

@@ -134,7 +134,7 @@ module Steep
       end
 
       def validate_type(type)
-        Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+        Steep.logger.debug { "#{Location.to_string type.location}: Validating #{type}..." }
 
         validator.validate_type(type, context: nil)
         validate_type_application(type)

data/lib/steep/subtyping/check.rb

@@ -850,8 +850,10 @@ module Steep
         relation.function!
 
         All(relation) do |result|
-          result.add(relation.map {|fun| fun.params }) do |rel|
-            check_method_params(name, rel)
+          if relation.sub_type.params && relation.super_type.params
+            result.add(relation.map {|fun| _ = fun.params }) do |rel|
+              check_method_params(name, rel)
+            end
           end
 
           result.add(relation.map {|fun| fun.return_type }) do |rel|
@@ -906,16 +908,23 @@ module Steep
       end
 
       def match_method_type_fails?(name, type1, type2)
-        match_params(name, Relation(type1.type.params, type2.type.params)).tap do |param_pairs|
-          return param_pairs unless param_pairs.is_a?(Array)
+        if type1.type.params && type2.type.params
+          match_params(name, Relation(type1.type.params, type2.type.params)).tap do |param_pairs|
+            return param_pairs unless param_pairs.is_a?(Array)
+          end
         end
 
         case result = expand_block_given(name, Relation(type1.block, type2.block))
         when Result::Base
           return result
         when Relation
-          match_params(name, result.map {|m| m.type.params }).tap do |param_pairs|
-            return param_pairs unless param_pairs.is_a?(Array)
+          type1.block or raise
+          type2.block or raise
+
+          if type1.block.type.params && type2.block.type.params
+            match_params(name, result.map {|m| _ = m.type.params }).tap do |param_pairs|
+              return param_pairs unless param_pairs.is_a?(Array)
+            end
           end
         end
 

data/lib/steep/subtyping/variable_variance.rb

@@ -46,7 +46,7 @@ module Steep
       end
 
       def self.add_params(params, block:, covariants:, contravariants:)
-        params.each_type do |type|
+        params&.each_type do |type|
           add_type(type, variance: block ? :contravariant : :covariant, covariants: covariants, contravariants: contravariants)
         end
       end
@@ -64,12 +64,12 @@ module Steep
             contravariants << type.name
           end
         when AST::Types::Proc
-          type.type.params.each_type do |type|
+          type.type.params&.each_type do |type|
             add_type(type, variance: variance, covariants: contravariants, contravariants: covariants)
           end
           add_type(type.type.return_type, variance: variance, covariants: covariants, contravariants: contravariants)
           if type.block
-            type.block.type.params.each_type do |type|
+            type.block.type.params&.each_type do |type|
               add_type(type, variance: variance, covariants: covariants, contravariants: contravariants)
             end
             add_type(type.type.return_type, variance: variance, covariants: contravariants, contravariants: covariants)