steep 0.40.0 → 0.44.0

data/lib/steep/server/signature_worker.rb

@@ -1,157 +0,0 @@
-module Steep
-  module Server
-    class SignatureWorker < BaseWorker
-      attr_reader :queue
-      attr_reader :last_target_validated_at
-
-      def initialize(project:, reader:, writer:, queue: Queue.new)
-        super(project: project, reader: reader, writer: writer)
-
-        @queue = queue
-        @last_target_validated_at = {}
-      end
-
-      def validate_signature_if_required(request)
-        path = source_path(URI.parse(request[:params][:textDocument][:uri]))
-
-        project.targets.each do |target|
-          if target.signature_file?(path)
-            enqueue_target target: target, timestamp: Time.now
-          end
-        end
-      end
-
-      def enqueue_target(target:, timestamp:)
-        Steep.logger.debug "queueing target #{target.name}@#{timestamp}"
-        last_target_validated_at[target] = timestamp
-        queue << [:validate, [target, timestamp]]
-      end
-
-      def enqueue_symbol(id:, query:)
-        Steep.logger.debug "queueing symbol #{query} (#{id})"
-        queue << [:symbol, [id, query]]
-      end
-
-      def handle_request(request)
-        case request[:method]
-        when "initialize"
-          # Start type checking.
-          project.targets.each do |target|
-            enqueue_target(target: target, timestamp: Time.now)
-          end
-
-          writer.write({ id: request[:id], result: nil})
-
-        when "textDocument/didChange"
-          update_source(request)
-          validate_signature_if_required(request)
-        when "workspace/symbol"
-          enqueue_symbol(query: request[:params][:query], id: request[:id])
-        end
-      end
-
-      def validate_signature(target, timestamp:)
-        Steep.logger.info "Starting signature validation: #{target.name} (#{timestamp})..."
-
-        target.type_check(target_sources: [], validate_signatures: true)
-
-        Steep.logger.info "Finished signature validation: #{target.name} (#{timestamp})"
-
-        diagnostics = case status = target.status
-                      when Project::Target::SignatureErrorStatus
-                        error_hash = status.errors.group_by {|error| error.location.buffer.name }
-                        formatter = Diagnostic::LSPFormatter.new
-
-                        target.signature_files.each_key.with_object({}) do |path, hash|
-                          errors = error_hash[path] || []
-                          hash[path] = errors.map {|error| formatter.format(error) }
-                        end
-                      when Project::Target::TypeCheckStatus
-                        target.signature_files.each_key.with_object({}) do |path, hash|
-                          hash[path] = []
-                        end
-                      else
-                        Steep.logger.info "Unexpected target status: #{status.class}"
-                        {}
-                      end
-
-        diagnostics.each do |path, diags|
-          writer.write(
-            method: :"textDocument/publishDiagnostics",
-            params: LSP::Interface::PublishDiagnosticsParams.new(
-              uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
-              diagnostics: diags
-            )
-          )
-        end
-      end
-
-      def active_job?(target, timestamp)
-        if last_target_validated_at[target] == timestamp
-          sleep 0.1
-          last_target_validated_at[target] == timestamp
-        end
-      end
-
-      def handle_workspace_symbol(query:, id:)
-        provider = Index::SignatureSymbolProvider.new()
-
-        project.targets.each do |target|
-          case target.status
-          when Project::Target::TypeCheckStatus
-            index = Index::RBSIndex.new()
-
-            builder = Index::RBSIndex::Builder.new(index: index)
-            builder.env(target.status.environment)
-
-            provider.indexes << index
-          end
-        end
-
-        symbols = provider.query_symbol(query)
-
-        result = symbols.map do |symbol|
-          {
-            name: symbol.name.to_s,
-            kind: symbol.kind,
-            deprecated: false,
-            containerName: symbol.container_name.to_s,
-            location: {
-              uri: URI.parse(project.absolute_path(symbol.location.buffer.name).to_s),
-              range: {
-                start: LSP::Interface::Position.new(
-                  line: symbol.location.start_line - 1,
-                  character: symbol.location.start_column,
-                  ),
-                end: LSP::Interface::Position.new(
-                  line: symbol.location.end_line - 1,
-                  character: symbol.location.end_column
-                )
-              }
-            }
-          }
-        end
-
-        writer.write(id: id, result: result)
-      end
-
-      def handle_job(job)
-        action, data = job
-
-        case action
-        when :validate
-          target, timestamp = data
-
-          if active_job?(target, timestamp)
-            validate_signature(target, timestamp: timestamp)
-          else
-            Steep.logger.info "Skipping signature validation: #{target.name}, queued timestamp=#{timestamp}, latest timestamp=#{last_target_validated_at[target]}"
-          end
-        when :symbol
-          id, query = data
-          handle_workspace_symbol(query: query, id: id)
-        end
-      end
-    end
-  end
-end

data/lib/steep/server/utils.rb

@@ -1,69 +0,0 @@
-module Steep
-  module Server
-    module Utils
-      LSP = LanguageServer::Protocol
-
-      def source_path(uri)
-        project.relative_path(Pathname(uri.path))
-      end
-
-      def apply_change(change, text)
-        range = change[:range]
-
-        if range
-          text = text.dup
-
-          buf = RBS::Buffer.new(name: :_, content: text)
-
-          start_pos = buf.loc_to_pos(range[:start].yield_self {|pos| [pos[:line]+1, pos[:character]] })
-          end_pos = buf.loc_to_pos(range[:end].yield_self {|pos| [pos[:line]+1, pos[:character]] })
-
-          text[start_pos...end_pos] = change[:text]
-          text
-        else
-          change[:text]
-        end
-      end
-
-      def update_source(request)
-        path = source_path(URI.parse(request[:params][:textDocument][:uri]))
-        version = request[:params][:textDocument][:version]
-        Steep.logger.info { "Updating source: path=#{path}, version=#{version}..." }
-
-        changes = request[:params][:contentChanges]
-
-        source_target, signature_targets = project.targets_for_path(path)
-
-        if source_target
-          changes.each do |change|
-            case
-            when source_target.source_file?(path)
-              Steep.logger.debug { "Updating source in #{source_target.name}: path=#{path}" }
-              source_target.update_source(path) {|text| apply_change(change, text) }
-            when source_target.possible_source_file?(path)
-              Steep.logger.debug { "Adding source to #{source_target.name}: path=#{path}" }
-              source_target.add_source(path, change[:text])
-            end
-          end
-        end
-
-        signature_targets.each do |target|
-          changes.each do |change|
-            case
-            when target.signature_file?(path)
-              Steep.logger.debug { "Updating signature in #{target.name}: path=#{path}" }
-              target.update_signature(path) {|text| apply_change(change, text) }
-            when target.possible_signature_file?(path)
-              Steep.logger.debug { "Adding signature to #{target.name}: path=#{path}" }
-              target.add_signature(path, change[:text])
-            end
-          end
-        end
-
-        if block_given?
-          yield path, version
-        end
-      end
-    end
-  end
-end

data/smoke/alias/test.yaml

@@ -1,73 +0,0 @@
----
-test:
-  a.rb:
-    diagnostics:
-    - |
-      a.rb:4:0: [error] Cannot find compatible overloading of method `+` of type `(::String | ::Integer)`
-      │ Method types:
-      │   def +: ((::string & ::Integer)) -> (::String | ::Integer)
-      │        | ((::string & ::Float)) -> (::String | ::Float)
-      │        | ((::string & ::Rational)) -> (::String | ::Rational)
-      │        | ((::string & ::Complex)) -> (::String | ::Complex)
-      │
-      │ Diagnostic ID: Ruby::UnresolvedOverloading
-      │
-      └ x + 123
-        ~~~~~~~
-    - |
-      a.rb:13:2: [error] Cannot assign a value of type `::String` to a variable of type `::Symbol`
-      │   ::String <: ::Symbol
-      │     ::Object <: ::Symbol
-      │       ::BasicObject <: ::Symbol
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └   z = x
-          ~~~~~
-    - |
-      a.rb:15:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::Symbol`
-      │   ::Integer <: ::Symbol
-      │     ::Numeric <: ::Symbol
-      │       ::Object <: ::Symbol
-      │         ::BasicObject <: ::Symbol
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └   z = x
-          ~~~~~
-  b.rb:
-    diagnostics:
-    - |
-      b.rb:6:0: [error] Cannot assign a value of type `::String` to a variable of type `::Integer`
-      │   ::String <: ::Integer
-      │     ::Object <: ::Integer
-      │       ::BasicObject <: ::Integer
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ x = a[0]
-        ~~~~~~~~
-  c.rb:
-    diagnostics:
-    - |
-      c.rb:3:0: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
-      │   ::Integer <: ::String
-      │     ::Numeric <: ::String
-      │       ::Object <: ::String
-      │         ::BasicObject <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ x = AliasMethodArg.new.foo(:foo)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    - |
-      c.rb:8:0: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
-      │   ::Integer <: ::String
-      │     ::Numeric <: ::String
-      │       ::Object <: ::String
-      │         ::BasicObject <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ x = AliasMethodArg.new.foo(name)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

data/smoke/and/test.yaml

@@ -1,24 +0,0 @@
----
-test:
-  a.rb:
-    diagnostics:
-    - |
-      a.rb:6:0: [error] Cannot assign a value of type `(::String | nil)` to a variable of type `::String`
-      │   (::String | nil) <: ::String
-      │     nil <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ b = a && a.to_str
-        ~~~~~~~~~~~~~~~~~
-    - |
-      a.rb:8:0: [error] Cannot assign a value of type `(::String | nil)` to a variable of type `::Integer`
-      │   (::String | nil) <: ::Integer
-      │     ::String <: ::Integer
-      │       ::Object <: ::Integer
-      │         ::BasicObject <: ::Integer
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ c = a && a.to_str
-        ~~~~~~~~~~~~~~~~~

data/smoke/array/test.yaml

@@ -1,80 +0,0 @@
----
-test:
-  a.rb:
-    diagnostics:
-    - |
-      a.rb:6:0: [error] Cannot find compatible overloading of method `[]=` of type `::Array[::Integer]`
-      │ Method types:
-      │   def []=: (::int, ::Integer) -> ::Integer
-      │          | (::int, ::int, ::Integer) -> ::Integer
-      │          | (::int, ::int, ::Array[::Integer]) -> ::Array[::Integer]
-      │          | (::int, ::int, nil) -> nil
-      │          | (::Range[::Integer], ::Integer) -> ::Integer
-      │          | (::Range[::Integer], ::Array[::Integer]) -> ::Array[::Integer]
-      │          | (::Range[::Integer], nil) -> nil
-      │
-      │ Diagnostic ID: Ruby::UnresolvedOverloading
-      │
-      └ a[2] = "foo"
-        ~~~~~~~~~~~~
-    - |
-      a.rb:12:0: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
-      │   ::Integer <: ::String
-      │     ::Numeric <: ::String
-      │       ::Object <: ::String
-      │         ::BasicObject <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ s = a[1]
-        ~~~~~~~~
-    - |
-      a.rb:18:0: [error] Cannot assign a value of type `::String` to a variable of type `::Integer`
-      │   ::String <: ::Integer
-      │     ::Object <: ::Integer
-      │       ::BasicObject <: ::Integer
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ i = b[1]
-        ~~~~~~~~
-  b.rb:
-    diagnostics:
-    - |
-      b.rb:11:0: [error] Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Array[::String]`
-      │   ::Array[::Integer] <: ::Array[::String]
-      │     ::Integer <: ::String
-      │       ::Numeric <: ::String
-      │         ::Object <: ::String
-      │           ::BasicObject <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ b = a
-        ~~~~~
-    - |
-      b.rb:12:0: [error] Cannot assign a value of type `::Array[::String]` to a variable of type `::Array[::Integer]`
-      │   ::Array[::String] <: ::Array[::Integer]
-      │     ::String <: ::Integer
-      │       ::Object <: ::Integer
-      │         ::BasicObject <: ::Integer
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ a = b
-        ~~~~~
-  c.rb:
-    diagnostics:
-    - |
-      c.rb:6:0: [error] Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Array[(::String | nil)]`
-      │   ::Array[::Integer] <: ::Array[(::String | nil)]
-      │     ::Integer <: (::String | nil)
-      │       ::Integer <: ::String
-      │         ::Numeric <: ::String
-      │           ::Object <: ::String
-      │             ::BasicObject <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ x = [1]
-        ~~~~~~~

data/smoke/block/test.yaml

@@ -1,96 +0,0 @@
----
-test:
-  a.rb:
-    diagnostics:
-    - |
-      a.rb:8:0: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
-      │   ::Integer <: ::String
-      │     ::Numeric <: ::String
-      │       ::Object <: ::String
-      │         ::BasicObject <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ s = a.foo
-        ~~~~~~~~~
-    - |
-      a.rb:10:0: [error] Cannot assign a value of type `::String` to a variable of type `::Integer`
-      │   ::String <: ::Integer
-      │     ::Object <: ::Integer
-      │       ::BasicObject <: ::Integer
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ i = a.foo { nil }
-        ~~~~~~~~~~~~~~~~~
-  b.rb:
-    diagnostics:
-    - |
-      b.rb:5:2: [error] Cannot break with a value of type `::Integer` because type `::Symbol` is assumed
-      │   ::Integer <: ::Symbol
-      │     ::Numeric <: ::Symbol
-      │       ::Object <: ::Symbol
-      │         ::BasicObject <: ::Symbol
-      │
-      │ Diagnostic ID: Ruby::BreakTypeMismatch
-      │
-      └   break 3
-          ~~~~~~~
-    - |
-      b.rb:10:0: [error] Cannot assign a value of type `(::Integer | ::Symbol)` to a variable of type `::String`
-      │   (::Integer | ::Symbol) <: ::String
-      │     ::Integer <: ::String
-      │       ::Numeric <: ::String
-      │         ::Object <: ::String
-      │           ::BasicObject <: ::String
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ s = a.bar do |x|
-        ~~~~~~~~~~~~~~~~
-  c.rb:
-    diagnostics: []
-  d.rb:
-    diagnostics:
-    - |
-      d.rb:6:0: [error] Cannot assign a value of type `::Array[::String]` to a variable of type `::Array[::Float]`
-      │   ::Array[::String] <: ::Array[::Float]
-      │     ::String <: ::Float
-      │       ::Object <: ::Float
-      │         ::BasicObject <: ::Float
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ b = [1,2,3].map(&a)
-        ~~~~~~~~~~~~~~~~~~~
-    - |
-      d.rb:8:0: [error] Cannot assign a value of type `::Array[::String]` to a variable of type `::Array[::Float]`
-      │   ::Array[::String] <: ::Array[::Float]
-      │     ::String <: ::Float
-      │       ::Object <: ::Float
-      │         ::BasicObject <: ::Float
-      │
-      │ Diagnostic ID: Ruby::IncompatibleAssignment
-      │
-      └ b = [1,2,3].map(&:to_s)
-        ~~~~~~~~~~~~~~~~~~~~~~~
-    - |
-      d.rb:10:0: [error] Cannot find compatible overloading of method `map` of type `::Array[::Integer]`
-      │ Method types:
-      │   def map: [U] () { (::Integer) -> U } -> ::Array[U]
-      │          | () -> ::Enumerator[::Integer, ::Array[untyped]]
-      │
-      │ Diagnostic ID: Ruby::UnresolvedOverloading
-      │
-      └ [1,2,3].map(&:no_such_method)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    - |
-      d.rb:11:0: [error] Cannot find compatible overloading of method `map` of type `::Array[::Integer]`
-      │ Method types:
-      │   def map: [U] () { (::Integer) -> U } -> ::Array[U]
-      │          | () -> ::Enumerator[::Integer, ::Array[untyped]]
-      │
-      │ Diagnostic ID: Ruby::UnresolvedOverloading
-      │
-      └ [1,2,3].map(&:divmod)
-        ~~~~~~~~~~~~~~~~~~~~~