yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/server/lifecycle_handler.rb

@@ -39,14 +39,30 @@ module Yoda
         }
       end
 
+      # @param params [LanguageServer::Protocol::Interface::InitializeParams]
       def handle_initialize(params)
         Instrument.instance.hear(initialization_progress: method(:notify_initialization_progress)) do
-          @session = Session.new(params[:root_uri])
+          @session = begin
+            if params[:workspace_folders]
+              workspace_folders = params[:workspace_folders].map { |hash| LanguageServer::Protocol::Interface::WorkspaceFolder.new(name: hash[:name], uri: hash[:uri]) }
+              Session.from_workspace_folders(workspace_folders)
+            elsif params[:root_uri]
+              Session.from_root_uri(params[:root_uri])
+            else
+              Session.new(workspaces: [])
+            end
+          end
+
           send_warnings(@session.setup || [])
 
           LanguageServer::Protocol::Interface::InitializeResult.new(
+            server_info: {
+              name: "yoda",
+              version: Yoda::VERSION,
+            },
             capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
+                open_close: true,
                 change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
                 save: LanguageServer::Protocol::Interface::SaveOptions.new(
                   include_text: true,
@@ -61,10 +77,49 @@ module Yoda
               signature_help_provider: LanguageServer::Protocol::Interface::SignatureHelpOptions.new(
                 trigger_characters: ['(', ','],
               ),
+              workspace_symbol_provider: LanguageServer::Protocol::Interface::WorkspaceSymbolOptions.new(
+                work_done_progress: true,
+              ),
+              workspace: {
+                workspaceFolders: LanguageServer::Protocol::Interface::WorkspaceFoldersServerCapabilities.new(
+                  supported: true,
+                  change_notifications: true,
+                ),
+                fileOperations: {
+                  didCreate: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                    filters: [
+                      LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                        pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                          glob: "**/*",
+                        ),
+                      ),
+                    ],
+                  ),
+                  didRename: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                    filters: [
+                      LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                        pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                          glob: "**/*",
+                        ),
+                      ),
+                    ],
+                  ),
+                  didDelete: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                    filters: [
+                      LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                        pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                          glob: "**/*",
+                        ),
+                      ),
+                    ],
+                  ),
+                },
+              },
             ),
           )
         end
       rescue => e
+        Logger.warn e.full_message
         LanguageServer::Protocol::Interface::ResponseError.new(
           message: "Failed to initialize yoda: #{e.class} #{e.message}",
           code: LanguageServer::Protocol::Constant::ErrorCodes::SERVER_ERROR_START,
@@ -98,7 +153,7 @@ module Yoda
 
         notifier.show_message(
           type: :warning,
-          message: "Failed to load some libraries (Please check console for details)",
+          message: warning_summary(core_import_errors, gem_import_errors),
         )
 
         if gem_message = gem_import_warnings(gem_import_errors)
@@ -116,6 +171,17 @@ module Yoda
         end
       end
 
+      def warning_summary(core_import_errors, gem_import_errors)
+        error_list = []
+        error_list += ["- core library"] unless core_import_errors.empty?
+        error_list += gem_import_errors.map { |error| "- #{error.name} (#{error.version})" }
+
+        <<~EOS
+        Failed to load some libraries
+        #{error_list.join("\n")}
+        EOS
+      end
+
       # @param gem_import_errors [Array<GemImportError>]
       # @return [String, nil]
       def gem_import_warnings(gem_import_errors)
@@ -140,8 +206,19 @@ module Yoda
         EOS
       end
 
-      def notify_initialization_progress(phase: nil, message: nil, **params)
-        notifier.event(type: :initialization, phase: phase, message: message)
+      def notify_initialization_progress(phase: nil, message: nil, index:, length:)
+        if length && length > 0
+          percentage = (index || 0) * 100 / length
+          if index <= 0
+            notifier.start_progress(id: phase, title: phase, message: message, percentage: percentage)
+          elsif index >= length
+            notifier.done_progress(id: phase)
+          else
+            notifier.report_progress(id: phase, message: message, percentage: percentage)
+          end
+        else
+          notifier.event(type: :initialization, phase: phase, message: message)
+        end
       end
     end
   end

data/lib/yoda/server/notifier.rb

@@ -8,10 +8,17 @@ module Yoda
 
       # @param type [Symbol]
       def busy(type:, id: nil)
+        failed = false
         event(type: type, phase: :begin, id: id)
+        start_progress(id: id, title: type)
         yield
+      rescue => e
+        Logger.warn(e.full_message)
+        failed = true
+        raise e 
       ensure
         event(type: type, phase: :end, id: id)
+        failed ? cancel_progress(id: id) : done_progress(id: id)
       end
 
       # @param params [Hash]
@@ -19,6 +26,77 @@ module Yoda
         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:)
@@ -43,9 +121,62 @@ module Yoda
         )
       end
 
+      # @param id [String, Symbol]
+      # @param title [String]
+      # @param calcellable [Boolean]
+      # @param message [String, nil]
+      # @param percentage [Integer]
+      def start_progress(id:, title:, cancellable: false, message: nil, percentage: 0)
+        write(
+          method: 'window/progress/start',
+          params: {
+            id: id,
+            title: title,
+            calcellable: cancellable,
+            message: message,
+            percentage: percentage,
+          }
+        )
+      end
+
+      # @param id [String, Symbol]
+      # @param message [String, nil]
+      # @param percentage [Integer, nil]
+      def report_progress(id:, message: nil, percentage: nil)
+        write(
+          method: 'window/progress/report',
+          params: {
+            id: id,
+            message: message,
+            percentage: percentage,
+          }
+        )
+      end
+
+      # @param id [String, Symbol]
+      def done_progress(id:)
+        write(
+          method: 'window/progress/done',
+          params: {
+            id: id,
+          }
+        )
+      end
+
+      # @param id [String, Symbol]
+      def cancel_progress(id:)
+        write(
+          method: 'window/progress/cancel',
+          params: {
+            id: id,
+          }
+        )
+      end
+
       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