yoda-language-server 0.7.2 → 0.10.0

data/lib/yoda/parsing/source_cutter.rb

@@ -1,9 +1,13 @@
 module Yoda
   module Parsing
+    # SourceCutter modifies the given source to fix parse errors around the location.
     class SourceCutter
       class CannotRecoverError < StandardError; end
 
       attr_reader :source, :current_location
+
+      # @param source [String]
+      # @param current_location [Location]
       def initialize(source, current_location)
         @source = source
         @current_location = current_location
@@ -36,7 +40,7 @@ module Yoda
       # @return [Array<(Symbol, (String, ::Parser::Source::Range))>]
       def tokens_of_source
         @tokens_of_source ||= begin
-          _, _, tokens = ::Parser::CurrentRuby.new.tokenize(::Parser::Source::Buffer.new("(string)").tap { |b| b.source = source }, true)
+          _, _, tokens = Parser.new.tokenize(source, recover: true)
           tokens
         end
       end
@@ -103,7 +107,7 @@ module Yoda
         # @return [Symbol, nil]
         def diagnostic
           begin
-            ::Parser::CurrentRuby.parse(to_s)
+            Parsing::Parser.new.parse(to_s)
             nil
           rescue ::Parser::SyntaxError => ex
             fail CannotRecoverError, "Cannot recover: #{ex.diagnostic.render}" unless ex.diagnostic.reason == :unexpected_token

data/lib/yoda/parsing/traverser/matcher.rb

@@ -0,0 +1,65 @@
+module Yoda
+  module Parsing
+    class Traverser
+      class Matcher
+        # @return [Symbol, nil]
+        attr_reader :type
+
+        # @return [Symbol, nil]
+        attr_reader :name
+
+        # @return [Proc, nil]
+        attr_reader :predicate
+
+        # @param type [Symbol, nil]
+        # @param name [Symbol, nil]
+        def initialize(type: nil, name: nil, &predicate)
+          @type = type
+          @name = name
+          @predicate = predicate
+        end
+
+        # @param node [AST::Node]
+        # @return [Boolean]
+        def match?(node)
+          return false if type && type != node.type
+          return false if name && name != name_of(node)
+          return false if predicate && !predicate.call(node)
+          true
+        end
+
+        # @param node [AST::Node]
+        # @return [Symbol, nil]
+        # @see https://github.com/whitequark/parser/blob/v2.5.3.0/doc/AST_FORMAT.md
+        def name_of(node)
+          case node.type
+          when :lvar, :ivar, :cvar, :gvar
+            node.name
+          when :lvasgn, :ivasgn, :cvasgn, :gvasgn
+            node.assignee.try(:name)
+          when :const
+            node.name.name
+          when :casgn
+            node.assignee.name
+          when :sym
+            node.value
+          when :send, :csend
+            node.selector.name
+          when :"op-asgn"
+            node.children[1].name
+          when :def
+            node.name_clause.name
+          when :defs
+            node.name_clause.name
+          when :arg, :blockarg, :kwarg
+            node.content.try(:name)
+          when :optarg, :kwoptarg
+            node.content.try(:name)
+          when :restarg, :kwrestarg
+            node.content.try(:name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/traverser/query_interface.rb

@@ -0,0 +1,68 @@
+module Yoda
+  module Parsing
+    class Traverser
+      module QueryInterface
+        # @return [Traverser, nil]
+        def query(**kwargs, &predicate)
+          result = select(**kwargs, &predicate).first
+          result ? Traverser.new(result) : nil
+        end
+
+        # @return [ResultSet]
+        def query_all(**kwargs, &predicate)
+          ResultSet.new(select(**kwargs, &predicate))
+        end
+
+        # @return [Traverser, nil]
+        def query_ancestor(**kwargs, &predicate)
+          result = select_ancestors(**kwargs, &predicate).first
+          result ? Traverser.new(result) : nil
+        end
+
+        # @return [Traverser, nil]
+        def query_ancestors(**kwargs, &predicate)
+          ResultSet.new(select_ancestors(**kwargs, &predicate))
+        end
+
+        private
+
+        # @return [Enumerable<AST::Node>]
+        def select(**kwargs, &predicate)
+          matcher = Matcher.new(**kwargs, &predicate)
+          all_nodes.select { |node| matcher.match?(node) }
+        end
+
+        # @return [Enumerable<AST::Node>]
+        def select_ancestors(**kwargs, &predicate)
+          matcher = Matcher.new(**kwargs, &predicate)
+          nesting.select { |node| matcher.match?(node) }
+        end
+
+        # @param node [AST::Node]
+        # @return [Enumerable<AST::Node>]
+        def all_nodes_for(node)
+          Enumerator.new { |yielder| repeat_for(node, yielder) }.lazy
+        end
+
+        # @param node [AST::Node]
+        # @param yielder [Enumerator::Yielder]
+        def repeat_for(node, yielder)
+          yielder << node
+          node.children.select { |node| node.is_a?(AST::Node) }.each { |node| repeat_for(node, yielder) }
+        end
+
+        # @abstract
+        # @return [Enumerable<AST::Node>]
+        def all_nodes
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Enumerable<AST::Node>]
+        def nesting
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/traverser/result_set.rb

@@ -0,0 +1,37 @@
+require 'forwardable'
+
+module Yoda
+  module Parsing
+    class Traverser
+      class ResultSet
+        extend Forwardable
+        include QueryInterface
+        include Enumerable
+
+        # @return [Enumerable<AST::Node>]
+        attr_reader :nodes
+        delegate each: :nodes
+
+        # @params nodes [AST::Node]
+        def initialize(nodes)
+          @nodes = nodes
+        end
+
+        # @return [Enumerable<AST::Node>]
+        def all_nodes
+          flat_map(&method(:all_nodes_for))
+        end
+
+        # @return [Enumerable<AST::Node>]
+        def nesting
+          flat_map(&method(:nesting))
+        end
+
+        # @return [Array<AST::Node>]
+        def to_a
+          nodes.to_a
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/traverser.rb

@@ -0,0 +1,29 @@
+module Yoda
+  module Parsing
+    # Traverser searches {AST::Node} with the given queries.
+    class Traverser
+      require 'yoda/parsing/traverser/query_interface'
+      require 'yoda/parsing/traverser/matcher'
+      require 'yoda/parsing/traverser/result_set'
+      include QueryInterface
+
+      # @return [AST::Node]
+      attr_reader :node
+
+      # @param node [AST::Node]
+      def initialize(node)
+        @node = node
+      end
+
+      # @return [Enumerable<AST::Node>]
+      def all_nodes
+        all_nodes_for(node)
+      end
+
+      # @return [Enumerable<AST::Node>]
+      def nesting
+        node.nesting
+      end
+    end
+  end
+end

data/lib/yoda/parsing/type_parser.rb

@@ -3,12 +3,12 @@ require 'parslet'
 module Yoda
   module Parsing
     class TypeParser
-      # @return [Model::Types::Base]
+      # @return [Model::TypeExpressions::Base]
       def parse(str)
         Generator.new.apply(Parser.new.parse(str))
       end
 
-      # @return [Model::Types::Base, nil]
+      # @return [Model::TypeExpressions::Base, nil]
       def safe_parse(str)
         parse(str)
       rescue Parslet::ParseFailed => failure
@@ -80,20 +80,20 @@ module Yoda
         rule(params: sequence(:param_types), return_type: simple(:return_type)) { Generator.create_function_type(nil, param_types, return_type) }
         rule(params: simple(:param_type), return_type: simple(:return_type)) { Generator.create_function_type(nil, [param_type], return_type) }
 
-        rule(instance_type: simple(:class_name)) { Model::Types::InstanceType.new(class_name.to_s) }
-        rule(module_type: simple(:module_name)) { Model::Types::ModuleType.new(module_name.to_s) }
-        rule(value_type: simple(:value_name)) { Model::Types::ValueType.new(value_name.to_s) }
-        rule(any_type: simple(:any)) { Model::Types::AnyType.new }
+        rule(instance_type: simple(:class_name)) { Model::TypeExpressions::InstanceType.new(class_name.to_s) }
+        rule(module_type: simple(:module_name)) { Model::TypeExpressions::ModuleType.new(module_name.to_s) }
+        rule(value_type: simple(:value_name)) { Model::TypeExpressions::ValueType.new(value_name.to_s) }
+        rule(any_type: simple(:any)) { Model::TypeExpressions::AnyType.new }
 
-        rule(sequence_type: simple(:type)) { Model::Types::SequenceType.new(Model::Types::InstanceType.new('::Array'), [type]) }
-        rule(sequence_type: sequence(:types)) { Model::Types::SequenceType.new(Model::Types::InstanceType.new('::Array'), types) }
+        rule(sequence_type: simple(:type)) { Model::TypeExpressions::SequenceType.new(Model::TypeExpressions::InstanceType.new('::Array'), [type]) }
+        rule(sequence_type: sequence(:types)) { Model::TypeExpressions::SequenceType.new(Model::TypeExpressions::InstanceType.new('::Array'), types) }
 
         rule(generic_abs: simple(:generic_abs), generic_abs_body: simple(:type)) { type }
 
         rule(base_type: simple(:base_type)) { base_type }
-        rule(base_type: simple(:base_type), generic_type_params: simple(:type_param)) { Model::Types::GenericType.new(base_type, [type_param]) }
-        rule(base_type: simple(:base_type), generic_type_params: sequence(:type_params)) { Model::Types::GenericType.new(base_type, type_params) }
-        rule(union_type: sequence(:types)) { Model::Types::UnionType.new(types) }
+        rule(base_type: simple(:base_type), generic_type_params: simple(:type_param)) { Model::TypeExpressions::GenericType.new(base_type, [type_param]) }
+        rule(base_type: simple(:base_type), generic_type_params: sequence(:type_params)) { Model::TypeExpressions::GenericType.new(base_type, type_params) }
+        rule(union_type: sequence(:types)) { Model::TypeExpressions::UnionType.new(types) }
 
         def self.create_function_type(context, param_types, return_type)
           func_options = param_types.each_with_object({ context: context, return_type: return_type }).with_index do |(param, func_options), index|
@@ -101,30 +101,30 @@ module Yoda
             when :required
               if func_options[:rest_parameter]
                 func_options[:post_parameters] ||= []
-                func_options[:post_parameters].push(param.type)
+                func_options[:post_parameters].push(param.to_paramter)
               else
                 func_options[:required_parameters] ||= []
-                func_options[:required_parameters].push(param.type)
+                func_options[:required_parameters].push(param.to_paramter)
               end
             when :optional
               func_options[:optional_parameters] ||= []
-              func_options[:optional_parameters].push(param.type)
+              func_options[:optional_parameters].push(param.to_paramter)
             when :rest
-              func_options[:rest_parameter] = param.type
+              func_options[:rest_parameter] = param.to_paramter
             when :required_keyword
               func_options[:required_keyword_parameters] ||= []
-              func_options[:required_keyword_parameters].push(param.keyword, param.type)
+              func_options[:required_keyword_parameters].push(param.to_paramter)
             when :optional_keyword
               func_options[:optional_keyword_parameters] ||= []
-              func_options[:optional_keyword_parameters].push(param.keyword, param.type)
+              func_options[:optional_keyword_parameters].push(param.to_paramter)
             when :keyword_rest
-              func_options[:keyword_rest_parameter] = param.type
+              func_options[:keyword_rest_parameter] = param.to_paramter
             when :block
-              func_options[:block_parameter] = param.type
+              func_options[:block_parameter] = param.to_paramter
             end
           end
 
-          Model::Types::FunctionType.new(func_options)
+          Model::TypeExpressions::FunctionType.new(**func_options)
         end
 
         class Param
@@ -134,6 +134,10 @@ module Yoda
             @keyword = keyword
             @type = type
           end
+
+          def to_paramter
+            Model::TypeExpressions::FunctionType::Parameter.new(name: keyword, type: type)
+          end
         end
       end
     end

data/lib/yoda/parsing.rb

@@ -3,7 +3,6 @@ module Yoda
     require 'yoda/parsing/ast_traversable'
     require 'yoda/parsing/comment_tokenizer'
     require 'yoda/parsing/parser'
-    require 'yoda/parsing/source_analyzer'
     require 'yoda/parsing/node_objects'
     require 'yoda/parsing/location'
     require 'yoda/parsing/scopes'
@@ -11,5 +10,32 @@ module Yoda
     require 'yoda/parsing/range'
     require 'yoda/parsing/query'
     require 'yoda/parsing/type_parser'
+    require 'yoda/parsing/traverser'
+
+    class << self
+      # @see {Parser#parse}
+      def parse(*args)
+        Parser.new.parse(*args)
+      end
+
+      # @see {Parser#parse_with_comments}
+      def parse_with_comments(*args)
+        Parser.new.parse_with_comments(*args)
+      end
+
+      # @see {Parser#parse_with_comments_if_valid}
+      def parse_with_comments_if_valid(*args)
+        Parser.new.parse_with_comments_if_valid(*args)
+      end
+
+      # Fix parse errors of the given source and return the modified source.
+      # @param source [String]
+      # @param location [Location]
+      # @return [String] Modified source to fix parse errors.
+      # @raise [SourceCutter::CannotRecoverError]
+      def fix_parse_error(source:, location:)
+        SourceCutter.new(source, location).error_recovered_source
+      end
+    end
   end
 end

data/lib/yoda/presentation/code_completion/constant.rb

@@ -0,0 +1,27 @@
+module Yoda
+  module Constant
+    class Candidates
+      def initialize(constant_candidates:, range:, prefix:)
+        @constant_candidates = constant_candidates
+        @range = range
+        @prefix = prefix
+      end
+
+      # @param object [Store::Objects::Base]
+      # @return [Symbol]
+      def complete_item_kind(object)
+        case object.kind
+        when :class
+          :class
+        when :module
+          :module
+        else
+          :constant
+        end
+      end
+    end
+
+    class Candidate
+    end
+  end
+end

data/lib/yoda/server/concurrent_writer.rb

@@ -2,7 +2,7 @@ module Yoda
   class Server
     # Wrapper class for writer to make thread safe
     class ConcurrentWriter
-      # @param [::LanguageServer::Protocol::Transport::Stdio::Writer]
+      # @param channel [::LanguageServer::Protocol::Transport::Stdio::Writer]
       def initialize(channel)
         @channel = channel
         @mutex = Mutex.new

data/lib/yoda/server/lifecycle_handler.rb

@@ -1,9 +1,12 @@
 require 'concurrent'
+require 'yoda/server/providers'
 
 module Yoda
   class Server
     # Handle
     class LifecycleHandler
+      include Providers::ReportableProgress
+
       # @return [Session, nil]
       attr_reader :session
 
@@ -39,32 +42,96 @@ 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])
-          send_warnings(@session.setup || [])
-
-          LanguageServer::Protocol::Interface::InitializeResult.new(
-            capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
-              text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
-                save: LanguageServer::Protocol::Interface::SaveOptions.new(
-                  include_text: true,
-                ),
-              ),
-              completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
-                resolve_provider: false,
-                trigger_characters: ['.', '@', '[', ':', '!', '<'],
-              ),
-              hover_provider: true,
-              definition_provider: true,
-              signature_help_provider: LanguageServer::Protocol::Interface::SignatureHelpOptions.new(
-                trigger_characters: ['(', ','],
+        in_progress(params, title: "Initializing Yoda") do |progress_reporter|
+          reporter = InitializationProgressReporter.new(progress_reporter)
+
+          subscriptions = {
+            initialization_progress: reporter.public_method(:notify_initialization_progress),
+            build_library_registry: reporter.public_method(:notify_build_library_registry),
+          }
+
+          Instrument.instance.hear(**subscriptions) do
+            @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 || [])
+          end
+        end
+
+        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,
               ),
             ),
-          )
-        end
+            completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
+              resolve_provider: false,
+              trigger_characters: ['.', '@', '[', ':', '!', '<'],
+            ),
+            hover_provider: true,
+            definition_provider: true,
+            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: "**/*",
+                      ),
+                    ),
+                  ],
+                ),
+              },
+            },
+          ),
+        )
       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 +165,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 +183,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 +218,30 @@ module Yoda
         EOS
       end
 
-      def notify_initialization_progress(phase: nil, message: nil, **params)
-        notifier.event(type: :initialization, phase: phase, message: message)
+      class InitializationProgressReporter
+        # @return [Providers::ReportableProgress::ProgressReporter]
+        attr_reader :progress_reporter
+
+        # @param progress_reporter [Providers::ReportableProgress::ProgressReporter]
+        def initialize(progress_reporter)
+          @progress_reporter = progress_reporter
+        end
+
+        def notify_initialization_progress(phase: nil, message: nil, index:, length:)
+          if length && length > 0
+            percentage = (index || 0) * 100 / length
+
+            progress_reporter.report(message: message, percentage: percentage)
+          else
+            progress_reporter.report(message: message)
+          end
+
+          progress_reporter.notifier.event(type: :initialization, phase: phase, message: message)
+        end
+
+        def notify_build_library_registry(message: nil, name: nil, version: nil)
+          progress_reporter.report(message: message)
+        end
       end
     end
   end