yoda-language-server 0.7.2 → 0.10.0

data/lib/yoda/server/notifier.rb

@@ -8,17 +8,94 @@ module Yoda
 
       # @param type [Symbol]
       def busy(type:, id: nil)
+        failed = false
         event(type: type, phase: :begin, id: id)
         yield
+      rescue => e
+        Logger.warn(e.full_message)
+        failed = true
+        event(type: type, phage: :failed, id: id)
+        raise e 
       ensure
         event(type: type, phase: :end, id: id)
       end
 
       # @param params [Hash]
-      def event(params)
+      def event(**params)
         write(method: 'telemetry/event', params: params)
       end
 
+      # @param token [Integer, String]
+      # @param title [String]
+      # @param cancellable [Boolean, nil]
+      # @param message [String]
+      # @param percentage [Integer]
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workDoneProgressBegin
+      def work_done_progress_begin(token:, title:, cancellable: nil, message: nil, percentage: nil)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: LanguageServer::Protocol::Interface::WorkDoneProgressBegin.new(
+              kind: "begin",
+              title: title,
+              cancellable: cancellable,
+              message: message,
+              percentage: percentage,
+            )
+          ),
+        )
+      end
+
+      # @param token [Integer, String]
+      # @param cancellable [Boolean, nil]
+      # @param message [String]
+      # @param percentage [Integer]
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workDoneProgressReport
+      def work_done_progress_report(token:, cancellable: nil, message: nil, percentage: nil)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: LanguageServer::Protocol::Interface::WorkDoneProgressReport.new(
+              kind: "report",
+              cancellable: cancellable,
+              message: message,
+              percentage: percentage,
+            )
+          ),
+        )
+      end
+
+      # @param token [Integer, String]
+      # @param message [String]
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workDoneProgressEnd
+      def work_done_progress_end(token:, message: nil)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: LanguageServer::Protocol::Interface::WorkDoneProgressEnd.new(
+              kind: "end",
+              message: message,
+            )
+          ),
+        )
+      end
+
+      # @param token [Integer, String]
+      # @param value [Object] The partial result to send. In most cases, the type of this becomes the result type of the request.
+      # @see https://microsoft.github.io/language-server-protocol/specifications/specification-current/#partialResults
+      def partial_result(token:, value:)
+        write(
+          method: '$/progress',
+          params: LanguageServer::Protocol::Interface::ProgressParams.new(
+            token: token,
+            value: value,
+          ),
+        )
+      end
+
       # @param type [String, Symbol]
       # @param message [String]
       def show_message(type:, message:)
@@ -46,6 +123,7 @@ module Yoda
       private
 
       def write(params)
+        Logger.trace("Notify: #{params}")
         @writer.write(params)
       end
 

data/lib/yoda/server/providers/completion.rb

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Completion < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/completion'
         end
@@ -13,31 +15,42 @@ module Yoda
           calculate(uri, position)
         end
 
+        private
+
         def timeout
           10
         end
 
-        private
+        def timeout_message(params)
+          uri = params[:text_document][:uri]
+          position = params[:position]
+
+          "#{self.class.provider_method}: #{uri}:#{position[:line]}:#{position[:character]}"
+        end
 
         # @param uri      [String]
         # @param position [{Symbol => Integer}]
         def calculate(uri, position)
-          source = session.file_store.get(uri)
+          workspace = session.workspace_for(uri)
+          source = workspace.read_at(uri)
           location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
 
-          if candidates = comment_complete(source, location)
-            return candidates
-          end
-          complete_from_cut_source(source, location)
+          Logger.trace("Trying comment completion for #{uri}, #{position}")
+          candidates = comment_complete(workspace, source, location)
+          return candidates if candidates
+
+          Logger.trace("Trying code completion for #{uri}, #{position}")
+          complete_from_cut_source(workspace, source, location)
         end
 
+        # @param workspace [Workspace]
         # @param source   [String]
         # @param location [Parsing::Location]
         # @return [LanguageServerProtocol::Interface::CompletionList, nil]
-        def comment_complete(source, location)
-          ast, comments = Parsing::Parser.new.parse_with_comments(source)
+        def comment_complete(workspace, source, location)
+          ast, comments = Parsing.parse_with_comments(source)
           return nil unless Parsing::Query::CurrentCommentQuery.new(comments, location).current_comment
-          completion_worker = Evaluation::CommentCompletion.new(session.registry, ast, comments, location)
+          completion_worker = Services::CommentCompletion.new(workspace.project.environment, ast, comments, location)
           return nil unless completion_worker.available?
 
           completion_items = completion_worker.candidates
@@ -50,12 +63,13 @@ module Yoda
           nil
         end
 
+        # @param workspace [Workspace]
         # @param source   [String]
         # @param location [Parsing::Location]
         # @return [LanguageServerProtocol::Interface::CompletionList, nil]
-        def complete_from_cut_source(source, location)
-          cut_source = Parsing::SourceCutter.new(source, location).error_recovered_source
-          method_completion_worker = Evaluation::CodeCompletion.new(session.registry, cut_source, location)
+        def complete_from_cut_source(workspace, source, location)
+          cut_source = Parsing.fix_parse_error(source: source, location: location)
+          method_completion_worker = Services::CodeCompletion.new(workspace.project.environment, cut_source, location)
           completion_items = method_completion_worker.candidates
 
           LanguageServer::Protocol::Interface::CompletionList.new(
@@ -68,13 +82,13 @@ module Yoda
         # @return            [LanguageServer::Protocol::Interface::CompletionItem]
         def create_completion_item(completion_item)
           LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: completion_item.description.is_a?(Model::Descriptions::FunctionDescription) ? completion_item.description.signature : completion_item.description.sort_text,
+            label: completion_item.label,
             kind: completion_item.language_server_kind,
-            detail: completion_item.description.title,
-            documentation: completion_item.description.to_markdown,
-            sort_text: completion_item.description.sort_text,
+            detail: completion_item.title,
+            documentation: completion_item.to_markdown,
+            sort_text: completion_item.sort_text,
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
-              range: LanguageServer::Protocol::Interface::Range.new(completion_item.range.to_language_server_protocol_range),
+              range: LanguageServer::Protocol::Interface::Range.new(**completion_item.language_server_range),
               new_text: completion_item.edit_text,
             ),
             data: {},

data/lib/yoda/server/providers/definition.rb

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Definition < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/definition'
         end
@@ -10,32 +12,58 @@ module Yoda
           calculate(params[:text_document][:uri], params[:position])
         end
 
+        private
+
         def timeout
           10
         end
 
-        private
+        def timeout_message(params)
+          uri = params[:text_document][:uri]
+          position = params[:position]
+
+          "#{self.class.provider_method}: #{uri}:#{position[:line]}:#{position[:character]}"
+        end
 
         # @param uri      [String]
         # @param position [{Symbol => Integer}]
         # @param include_declaration [Boolean]
         def calculate(uri, position, include_declaration = false)
-          source = session.file_store.get(uri)
+          workspace = session.workspace_for(uri)
+          source = workspace.read_at(uri)
           location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
 
-          node_worker = Evaluation::CurrentNodeExplain.new(session.registry, source, location)
-          references = node_worker.defined_files
-          references.map { |(path, line, column)| create_location(path, line, column) }
-        end
+          session.workspaces.each do |workspace|
+            next unless workspace.suburi?(uri)
+
+            node_worker = Services::CurrentNodeExplain.from_source(environment: workspace.project.environment, source: source, location: location)
+
+            if (current_comment_signature = node_worker.current_comment_signature)&.providable?
+              references = current_comment_signature.defined_files
+              locations = references.map { |(path, line, column)| create_location(workspace.uri_of_path(path), line, column) }
 
+              return locations unless locations.empty?
+            elsif current_node_signature = node_worker.current_node_signature
+              references = current_node_signature.defined_files
+              locations = references.map { |(path, line, column)| create_location(workspace.uri_of_path(path), line, column) }
+
+              return locations unless locations.empty?
+            else
+              nil
+            end
+          end
+
+          []
+        end
+        
         # @param path [String]
         # @param line [Integer]
         # @param column [Integer]
-        def create_location(path, line, column)
-          location = Parsing::Location.new(row: line - 1, column: column)
+        def create_location(uri, line, column)
+          location = Parsing::Location.new(row: line, column: column)
           LanguageServer::Protocol::Interface::Location.new(
-            uri: session.uri_of_path(path),
-            range: LanguageServer::Protocol::Interface::Range.new(Parsing::Range.new(location, location).to_language_server_protocol_range),
+            uri: uri,
+            range: LanguageServer::Protocol::Interface::Range.new(**Parsing::Range.new(location, location).to_language_server_protocol_range),
           )
         end
       end

data/lib/yoda/server/providers/hover.rb

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Hover < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/hover'
         end
@@ -10,36 +12,50 @@ module Yoda
           calculate(params[:text_document][:uri], params[:position])
         end
 
+        private
+
         def timeout
           10
         end
 
-        private
+        def timeout_message(params)
+          uri = params[:text_document][:uri]
+          position = params[:position]
+
+          "#{self.class.provider_method}: #{uri}:#{position[:line]}:#{position[:character]}"
+        end
+
 
         # @param uri      [String]
         # @param position [{Symbol => Integer}]
         def calculate(uri, position)
-          source = session.file_store.get(uri)
+          workspace = session.workspace_for(uri)
+          source = workspace.read_at(uri)
           location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
 
-          node_worker = Evaluation::CurrentNodeExplain.new(session.registry, source, location)
+          node_worker = Services::CurrentNodeExplain.from_source(environment: workspace.project.environment, source: source, location: location)
 
-          current_node_signature = node_worker.current_node_signature
-          create_hover(current_node_signature) if current_node_signature
+          if (current_comment_signature = node_worker.current_comment_signature)&.providable?
+            create_hover(current_comment_signature)
+          elsif current_node_signature = node_worker.current_node_signature
+            create_hover(current_node_signature)
+          else
+            nil
+          end
         end
 
-        # @param signature [Evaluation::NodeSignature]
+        # @param signature [Model::NodeSignatures::Base]
         def create_hover(signature)
           LanguageServer::Protocol::Interface::Hover.new(
             contents: signature.descriptions.map { |value| create_hover_text(value) },
-            range: LanguageServer::Protocol::Interface::Range.new(signature.node_range.to_language_server_protocol_range),
+            range: LanguageServer::Protocol::Interface::Range.new(**signature.node_range.to_language_server_protocol_range),
           )
         end
 
-        # @param description [Evaluation::Descriptions::Base]
-        # @return [String]
+        # @param description [Model::Descriptions::Base]
+        # @return [String, Hash]
         def create_hover_text(description)
-          description.to_markdown
+          description.markup_content
         end
       end
     end

data/lib/yoda/server/providers/reportable_progress.rb

@@ -0,0 +1,75 @@
+module Yoda
+  class Server
+    module Providers
+      module ReportableProgress
+        # @param params [Hash] The parameter of the request
+        def in_progress(params, title:)
+          begin
+            reporter = ProgressReporter.new(
+              work_done_token: params[:work_done_token],
+              partial_result_token: params[:partial_result_token],
+              notifier: notifier,
+            )
+
+            reporter.send_begin(title: title)
+            yield reporter
+
+           reporter.results
+          ensure
+            reporter.send_end
+          end
+        end
+
+        class ProgressReporter
+          # @param [String, Integer, nil]
+          attr_reader :work_done_token
+
+          # @param [String, Integer, nil]
+          attr_reader :partial_result_token
+
+          # @param [Notifier]
+          attr_reader :notifier
+
+          # @param [Array]
+          attr_reader :results
+
+          # @param work_done_token [String, Integer, nil]
+          # @param partial_result_token [String, Integer, nil]
+          # @param notifier [Notifier]
+          def initialize(work_done_token:, partial_result_token:, notifier:)
+            @work_done_token = work_done_token
+            @partial_result_token = partial_result_token
+            @notifier = notifier
+            @results = []
+          end
+
+          def send_begin(**kwargs)
+            if work_done_token
+              notifier.work_done_progress_begin(token: work_done_token, **kwargs)
+            end
+          end
+
+          def send_end(**kwargs)
+            if work_done_token
+              notifier.work_done_progress_end(token: work_done_token, **kwargs)
+            end
+          end
+
+          def report(**kwargs)
+            if work_done_token
+              notifier.work_done_progress_report(token: work_done_token, **kwargs)
+            end
+          end
+
+          def send_result(value)
+            if partial_result_token
+              notifier.partial_result(token: partial_result_token, value: value)
+            else
+              results.push(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/signature.rb

@@ -2,6 +2,8 @@ module Yoda
   class Server
     module Providers
       class Signature < Base
+        include WithTimeout
+
         def self.provider_method
           :'textDocument/signatureHelp'
         end
@@ -11,34 +13,45 @@ module Yoda
           calculate(params[:text_document][:uri], params[:position])
         end
 
+        private
+
         def timeout
           10
         end
 
-        private
+        def timeout_message(params)
+          uri = params[:text_document][:uri]
+          position = params[:position]
+
+          "#{self.class.provider_method}: #{uri}:#{position[:line]}:#{position[:character]}"
+        end
 
         # @params uri [String]
         # @params position [{Symbol => Integer}]
         def calculate(uri, position)
-          source = session.file_store.get(uri)
+          workspace = session.workspace_for(uri)
+          source = workspace.read_at(uri)
           location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
-          cut_source = Parsing::SourceCutter.new(source, location).error_recovered_source
+          cut_source = Parsing.fix_parse_error(source: source, location: location)
 
-          signature_worker = Evaluation::SignatureDiscovery.new(session.registry, cut_source, location)
+          signature_worker = Services::SignatureDiscovery.from_source(environment: workspace.project.environment, source: cut_source, location: location)
 
           functions = signature_worker.method_candidates
-          create_signature_help(functions)
+          argument_number = signature_worker.argument_number
+          create_signature_help(functions, argument_number)
         end
 
         # @param code_objects [Array<Model::FunctionSignatures::Base>]
-        def create_signature_help(functions)
+        # @param argument_number [Integer, nil]
+        def create_signature_help(functions, argument_number)
           signatures = functions.map { |func| Model::Descriptions::FunctionDescription.new(func) }
           LanguageServer::Protocol::Interface::SignatureHelp.new(
             signatures: signatures.map { |signature| create_signature_info(signature) },
+            active_parameter: argument_number,
           )
         end
 
-        # @param signature [Evaluation::Descriptions::FunctionDescription]
+        # @param signature [Services::Descriptions::FunctionDescription]
         def create_signature_info(signature)
           LanguageServer::Protocol::Interface::SignatureInformation.new(
             label: signature.title.to_s,

data/lib/yoda/server/providers/text_document_did_change.rb

@@ -9,7 +9,7 @@ module Yoda
         def provide(params)
           uri = params[:text_document][:uri]
           text = params[:content_changes].first[:text]
-          session.file_store.store(uri, text)
+          session.store_source(uri: uri, source: text)
 
           NO_RESPONSE
         end

data/lib/yoda/server/providers/text_document_did_open.rb

@@ -9,7 +9,7 @@ module Yoda
         def provide(params)
           uri = params[:text_document][:uri]
           text = params[:text_document][:text]
-          session.file_store.store(uri, text)
+          session.store_source(uri: uri, source: text)
 
           NO_RESPONSE
         end

data/lib/yoda/server/providers/with_timeout.rb

@@ -0,0 +1,36 @@
+require 'timeout'
+
+module Yoda
+  class Server
+    module Providers
+      module WithTimeout
+        module PrependHook
+          def provide(*args)
+            begin
+              Timeout.timeout(timeout) { super }
+            rescue Timeout::Error => err
+              if message = timeout_message(*args)
+                Logger.error("Request expired: " + message)
+              else
+                Logger.error("Request expired")
+              end
+              raise err
+            end
+          end
+        end
+
+        def included(mod)
+          mod.send(:prepend, PrependHook)
+        end
+
+        def timeout
+          nil
+        end
+
+        def timeout_message(*args)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/workspace_did_change_workspace_folders.rb

@@ -0,0 +1,33 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidChangeWorkspaceFolders < Base
+        def self.provider_method
+          :'workspace/didChangeWorkspaceFolders'
+        end
+
+        def provide(params)
+          added_folders = params[:event][:added].map(&method(:to_folder))
+          removed_folders = params[:event][:added].map(&method(:to_folder))
+
+          added_folders.each do
+            workspace = Workspace.from_workspace_folder(folder)
+            session.add_workspace(workspace)
+          end
+
+          removed_folders.each do
+            session.remove_workspace(id: folder.id)
+          end
+
+          NO_RESPONSE
+        end
+
+        private
+
+        def to_folder(folder_params)
+          LanguageServer::Protocol::Interface::WorkspaceFolder.new(**folder_params)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/workspace_did_create_files.rb

@@ -0,0 +1,21 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidCreateFiles < Base
+        def self.provider_method
+          :'workspace/didCreateFiles'
+        end
+
+        # @param params [LanguageServer::Protocol::Interface::CreateFilesParams]
+        def provide(params)
+          files = params[:files]
+          files.each do |file|
+            session.read_source(file[:uri])
+          end
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/workspace_did_delete_files.rb

@@ -0,0 +1,21 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidDeleteFiles < Base
+        def self.provider_method
+          :'workspace/didDeleteFiles'
+        end
+
+        # @param params [LanguageServer::Protocol::Interface::DeleteFilesParams]
+        def provide(params)
+          files = params[:files]
+          files.each do |file|
+            session.remove_source(uri: file[:uri])
+          end
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server/providers/workspace_did_rename_files.rb

@@ -0,0 +1,22 @@
+module Yoda
+  class Server
+    module Providers
+      class WorkspaceDidRenameFiles < Base
+        def self.provider_method
+          :'workspace/didRenameFiles'
+        end
+
+        # @param params [LanguageServer::Protocol::Interface::DeleteFilesParams]
+        def provide(params)
+          files = params[:files]
+          files.each do |file|
+            session.remove_source(uri: file[:old_uri])
+            session.read_source(file[:new_uri])
+          end
+
+          NO_RESPONSE
+        end
+      end
+    end
+  end
+end