yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/server/workspace.rb

@@ -0,0 +1,117 @@
+require 'uri'
+require 'forwardable'
+
+module Yoda
+  class Server
+    # Denotes workspace folder in LSP.
+    # @see: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_workspaceFolders
+    class Workspace
+      extend Forwardable
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :root_uri
+
+      delegate [:subpath?] => :file_tree
+
+      delegate [:uri_of_path] => :uri_encoder
+
+      # @param folder [LanguageServer::Protocol::Interface::WorkspaceFolder]
+      # @return [Workspace]
+      def self.from_workspace_folder(folder)
+        new(name: folder.name, root_uri: folder.uri)
+      end
+
+      # @param name [String]
+      # @param root_uri [String]
+      def initialize(name:, root_uri:)
+        @name = name
+        @root_uri = root_uri
+      end
+
+      # @return [Array<Exception>] errors on setup
+      def setup
+        project.setup
+      end
+
+      # @return [Store::Project, nil]
+      def project
+        @project ||= Store::Project.for_path(root_path)
+      end
+
+      # @return [String]
+      def root_path
+        UriDecoder.path_of_uri(root_uri)
+      end
+
+      # @param uri [String]
+      # @return [String, nil]
+      def read_at(uri)
+        path = UriDecoder.path_of_uri(uri)
+        path && file_tree.read_at(path)
+      end
+
+      # @param uri [String]
+      def read_source(uri)
+        path = UriDecoder.path_of_uri(uri)
+        return if !path || !program_file?(path)
+        file_tree.clear_editing_at(path)
+      end
+
+      # @param uri [String]
+      # @param source [String]
+      def store_source(uri:, source:)
+        path = UriDecoder.path_of_uri(uri)
+        return if !path || !program_file?(path)
+        file_tree.set_editing_at(path, source)
+      end
+
+      # @param uri [String]
+      def remove_source(uri:)
+        path = UriDecoder.path_of_uri(uri)
+        file_tree.mark_deleted(path)
+      end
+
+      def suburi?(uri)
+        path = UriDecoder.path_of_uri(uri)
+        path && subpath?(path)
+      end
+
+      private
+
+      # @return [Store::FileTree]
+      def file_tree
+        project.file_tree
+      end
+
+      # @return [UriEncoder]
+      def uri_encoder
+        @uri_encoder ||= UriEncoder.new(root_path)
+      end
+
+      # @param path [String]
+      # @return [Boolean]
+      def program_file?(path)
+        %w(.c .rb).include?(File.extname(path))
+      end
+
+      class UriEncoder
+        # @return [String]
+        attr_reader :base_path
+
+        # @param base_path [String]
+        def initialize(base_path)
+          @base_path = base_path
+        end
+
+        # @param path [String]
+        # @return [String]
+        def uri_of_path(path)
+          "file://#{File.expand_path(path, base_path)}"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/server.rb

@@ -4,13 +4,16 @@ require 'securerandom'
 module Yoda
   class Server
     require 'yoda/server/session'
-    require 'yoda/server/file_store'
     require 'yoda/server/concurrent_writer'
     require 'yoda/server/notifier'
     require 'yoda/server/providers'
     require 'yoda/server/root_handler'
     require 'yoda/server/lifecycle_handler'
     require 'yoda/server/deserializer'
+    require 'yoda/server/scheduler'
+    require 'yoda/server/workspace'
+    require 'yoda/server/uri_decoder'
+    require 'yoda/server/rootless_workspace'
 
     # @return [::LanguageServer::Protocol::Transport::Stdio::Reader]
     attr_reader :reader
@@ -35,14 +38,18 @@ module Yoda
     end
 
     def run
+      Logger.trace "Server initializing..."
       reader.read do |request|
         begin
           root_handler.handle(id: request[:id], method: request[:method].to_sym, params: deserialize(request[:params]))
         rescue StandardError => ex
           Logger.warn ex
-          Logger.warn ex.backtrace
+          Logger.warn ex.full_message
         end
       end
+      Logger.trace "Waiting to finish all pending tasks..."
+      root_handler.wait_for_termination(timeout: 10)
+      Logger.trace "Server finishing..."
     end
 
     def deserialize(hash)

data/lib/yoda/services/code_completion/base_provider.rb

@@ -0,0 +1,52 @@
+module Yoda
+  module Services
+    class CodeCompletion
+      # @abstract
+      # Base class of completion candidates providers for code completion.
+      # This class bridges analysis features such as syntastic analysis {#source_analyzer} and symbolic execiton {#evaluator}.
+      class BaseProvider
+        # @return [Model::Environment]
+        attr_reader :environment
+
+        # @return [AST::Vnode]
+        attr_reader :ast
+
+        # @return [Parsing::Location]
+        attr_reader :location
+
+        # @return [Evaluator]
+        attr_reader :evaluator
+
+        # @param environment [Model::Environment]
+        # @param ast [AST::Vnode]
+        # @param location [Parsing::Location]
+        # @param evaluator [Evaluator]
+        def initialize(environment, ast, location, evaluator)
+          @environment = environment
+          @ast = ast
+          @location = location
+          @evaluator = evaluator
+        end
+
+        # @abstract
+        # @return [true, false]
+        def providable?
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          fail NotImplementedError
+        end
+
+        private
+
+        # @return [AST::Node, nil]
+        def current_node
+          @current_node ||= ast.positionally_nearest_child(location)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/{evaluation → services}/code_completion/const_provider.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Evaluation
+  module Services
     class CodeCompletion
       class ConstProvider < BaseProvider
         # @return [true, false]
@@ -46,43 +46,53 @@ module Yoda
             end
         end
 
-        # @return [Parsing::NodeObjects::ConstNode, nil]
+        # @return [AST::Vnode, nil]
         def current_ancestor_const_node
-          @current_ancestor_const_node ||= begin
-            node = source_analyzer.nodes_to_current_location_from_root.reverse.take_while { |el| [:const, :cbase].include?(el.type) }.last
-            return nil if !node || node.type != :const
-            Parsing::NodeObjects::ConstNode.new(node)
-          end
+          nearst_constant_group = ast.positionally_nearest_child(location)&.nesting&.reverse&.find(&:constant?)
         end
 
         # @return [Array<Store::Objects::Base>]
         def const_candidates
           return [] unless providable?
-          return [] if const_parent_paths.empty?
 
-          base_path = current_ancestor_const_node.to_path
-          path = just_after_separator? ? Model::Path.from_names([base_path.spacename, '']) : base_path
-          scoped_path = Model::ScopedPath.new(const_parent_paths, path)
-          Store::Query::FindConstant.new(registry).select_with_prefix(scoped_path)
+          case current_ancestor_const_node.base.type
+          when :cbase
+            paths = evaluator.tracer.generator.object_class.value.select_constant_paths(constant_pattern)
+          when :empty
+            lexical_scope_types = evaluator.node_info(current_ancestor_const_node).lexical_scope_types
+            paths = lexical_scope_types.flat_map do |type| 
+              type.value.select_constant_paths(constant_pattern)
+            end.uniq
+          else
+            node_info = evaluator.node_info(current_ancestor_const_node.base)
+            paths = node_info.type.value.select_constant_paths(constant_pattern)
+          end
+            
+          paths.map(&method(:resolve_constant)).compact
         end
 
-        # @return [true, false]
-        def just_after_separator?
-          return @is_just_after_separator if instance_variable_defined?(:@is_just_after_separator)
-          @is_just_after_separator = current_ancestor_const_node.just_after_separator?(source_analyzer.location)
+        # @return [String, nil]
+        def constant_prefix
+          return nil unless providable?
+          base_name = just_after_separator? ? '' : current_ancestor_const_node.name.name.to_s
         end
 
-        # @return [Array<Store::Objects::Base>]
-        def const_parent_paths
-          @const_parent_paths ||= begin
-            lexical_scope(source_analyzer.current_namespace)
-          end
+        # @return [Regexp]
+        def constant_pattern
+          return /\A\Z/ unless providable?
+          /\A#{Regexp.escape(constant_prefix)}/
         end
 
-        # @param namespace [Parsing::NodeObjects::Namespace]
-        # @return [Array<Path>]
-        def lexical_scope(namespace)
-          namespace.paths_from_root.reverse.map { |name| Model::Path.build(name.empty? ? 'Object' : name.gsub(/\A::/, '')) }
+        # @return [true, false]
+        def just_after_separator?
+          return @is_just_after_separator if instance_variable_defined?(:@is_just_after_separator)
+          @is_just_after_separator = current_ancestor_const_node.just_after_separator?(location)
+        end
+        
+        # @param path [Path, String]
+        # @return [Store::Objects::Base, nil]
+        def resolve_constant(path)
+          environment.resolve_constant(path)
         end
       end
     end

data/lib/yoda/services/code_completion/keyword_provider.rb

@@ -0,0 +1,67 @@
+module Yoda
+  module Services
+    class CodeCompletion
+      class KeywordProvider < BaseProvider
+        KEYWORDS = %i(
+          __ENCODING__
+          __LINE__
+          __FILE__
+          BEGIN
+          END
+          alias
+          and
+          begin
+          break
+          case
+          class
+          def
+          defined?
+          do
+          else
+          elsif
+          end
+          ensure
+          false
+          for
+          if
+          in
+          module
+          next
+          nil
+          not
+          or
+          redo
+          rescue
+          retry
+          return
+          self
+          then
+          true
+          undef
+          unless
+          until
+          when
+          while
+          yield
+        )
+
+
+        # @return [true, false]
+        def providable?
+          true
+        end
+
+        # Returns constant candidates by using the current lexical scope.
+        # @return [Array<Model::CompletionItem>] constant candidates.
+        def candidates
+        end
+
+        private
+
+        def current_node
+          @current_node ||= source_analyzer.nodes_to_current_location_from_root.last
+        end
+      end
+    end
+  end
+end

data/lib/yoda/services/code_completion/local_variable_provider.rb

@@ -0,0 +1,51 @@
+module Yoda
+  module Services
+    class CodeCompletion
+      class LocalVariableProvider < BaseProvider
+
+        # @return [true, false]
+        def providable?
+          return false unless current_node
+          return true if index_word
+          false
+        end
+
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          return [] unless providable?
+          local_variables.select { |variable_name, _| variable_name.to_s.start_with?(index_word) }.map do |variable_name, type_expression|
+            Model::CompletionItem.new(
+              description: Model::Descriptions::VariableDescription.new(variable: variable_name, type: type_expression),
+              range: substitution_range,
+              kind: :variable,
+            )
+          end
+        end
+
+        private
+
+        # @return [Hash{Symbol => Typing::Types::Type}]
+        def local_variables
+          @local_variables ||= evaluator.context_variable_types(current_node) || {}
+        end
+
+        # @return [Range]
+        def substitution_range
+          current_node.range
+        end
+
+        # @return [String, nil]
+        def index_word
+          @index_word ||= begin
+            case current_node.type
+            when :ivar, :lvar, :gvar, :cvar
+              current_node.name.to_s
+            when :send
+              current_node.implicit_receiver? && current_node.selector_name.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/{evaluation → services}/code_completion/method_provider.rb

@@ -1,10 +1,10 @@
 module Yoda
-  module Evaluation
+  module Services
     class CodeCompletion
       class MethodProvider < BaseProvider
         # @return [true, false]
         def providable?
-          !!(current_send)
+          !!current_send
         end
 
         # @return [Array<Model::CompletionItem>]
@@ -27,48 +27,30 @@ module Yoda
           nil
         end
 
-        # @return [Array<Store::Objects::Method>]
+        # @return [Array<FunctionSignatures::Wrapper>]
         def method_candidates
           return [] unless providable?
-          receiver_values
-            .map { |value| Store::Query::FindSignature.new(registry).select(value, /\A#{Regexp.escape(index_word)}/, visibility: method_visibility_of_send_node(current_send)) }
-            .flatten
+          @method_candidates ||= receiver_type.value.select_method(/\A#{Regexp.escape(index_word)}/, visibility: method_visibility)
         end
 
-        # @param send_node [Parsing::NodeObjects::SendNode]
         # @return [Array<Symbol>]
-        def method_visibility_of_send_node(send_node)
-          if send_node.receiver_node
-            %i(public)
-          else
+        def method_visibility
+          if current_send.implicit_receiver?
             %i(public private protected)
+          else
+            %i(public)
           end
         end
 
-        # @return [Array<Store::Objects::Base>]
-        def receiver_values
-          @receiver_values ||= begin
-            if current_receiver_node
-              evaluator.calculate_values(current_receiver_node)
-            else
-              # implicit call for self
-              [evaluator.scope_constant]
-            end
-          end
+        # @return [Typing::Types::Type, nil]
+        def receiver_type
+          return nil unless current_send
+          @receiver_type ||= evaluator.receiver_type(current_send)
         end
 
-        # @return [Parsing::NodeObjects::SendNode, nil]
+        # @return [AST::SendNode, nil]
         def current_send
-          @current_send ||= begin
-            node = source_analyzer.nodes_to_current_location_from_root.last
-            return nil unless node.type == :send
-            Parsing::NodeObjects::SendNode.new(node)
-          end
-        end
-
-        # @return [Parser::AST::Node, nil]
-        def current_receiver_node
-          current_send&.receiver_node
+          @current_send ||= current_node&.type == :send ? current_node : nil
         end
 
         # @return [String, nil]

data/lib/yoda/services/code_completion.rb

@@ -0,0 +1,74 @@
+module Yoda
+  module Services
+    class CodeCompletion
+      require 'yoda/services/code_completion/base_provider'
+      require 'yoda/services/code_completion/method_provider'
+      require 'yoda/services/code_completion/local_variable_provider'
+      require 'yoda/services/code_completion/const_provider'
+
+      # @return [Model::Environment]
+      attr_reader :environment
+
+      # @return [String]
+      attr_reader :source
+
+      # @return [Parsing::Location]
+      attr_reader :location
+
+      # @param environment [Model::Environment]
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      def initialize(environment, source, location)
+        @environment = environment
+        @source = source
+        @location = location
+      end
+
+      # @return [true, false]
+      def valid?
+        providers.any?(&:providable?)
+      end
+
+      # @return [Array<Model::CompletionItem>]
+      def candidates
+        unify(providers.select(&:providable?).map(&:candidates).flatten)
+      end
+
+      private
+
+      def unify(candidates)
+        candidates.each_with_object({}) { |candidate, memo| memo.update(candidate.sort_text => candidate) { |_key, old_value, new_value| old_value.merge(new_value) } }.values
+      end
+
+      # @return [Array<CodeCompletion::BaseProvider>]
+      def providers
+        [local_variable_provider, method_provider, const_provider]
+      end
+
+      # @return [MethodProvider]
+      def method_provider
+        @method_provider ||= MethodProvider.new(environment, ast, location, evaluator)
+      end
+
+      # @return [LocalVariableProvider]
+      def local_variable_provider
+        @local_variable_provider ||= LocalVariableProvider.new(environment, ast, location, evaluator)
+      end
+
+      # @return [ConstantProvider]
+      def const_provider
+        @constant_provider ||= ConstProvider.new(environment, ast, location, evaluator)
+      end
+
+      # @return [Yoda::AST::Vnode]
+      def ast
+        @ast ||= Yoda::Parsing.parse(source)
+      end
+
+      # @return [Evaluator]
+      def evaluator
+        @evaluator ||= Evaluator.new(ast: ast, environment: environment)
+      end
+    end
+  end
+end

data/lib/yoda/{evaluation → services}/comment_completion/base_provider.rb

@@ -1,10 +1,10 @@
 module Yoda
-  module Evaluation
+  module Services
     class CommentCompletion
       # @abstract
       class BaseProvider
-        # @type Store::Registry
-        attr_reader :registry
+        # @type Model::Environment
+        attr_reader :environment
 
         # @type ::Parser::AST::Node
         attr_reader :ast
@@ -15,12 +15,12 @@ module Yoda
         # @type Location
         attr_reader :location
 
-        # @param registry [Store::Registry]
+        # @param environment [Model::Environment]
         # @param ast      [::Parser::AST::Node]
         # @param comments [Array<::Parser::Source::Comment>]
         # @param location [Location]
-        def initialize(registry, ast, comments, location)
-          @registry = registry
+        def initialize(environment, ast, comments, location)
+          @environment = environment
           @ast = ast
           @comments = comments
           @location = location
@@ -40,6 +40,11 @@ module Yoda
 
         private
 
+        # @return [Evaluator]
+        def evaluator
+          @evaluator ||= Evaluator.new(ast: ast, environment: environment)
+        end
+
         # @return [Parsing::Query::CurrentCommentTokenQuery]
         def current_comment_token_query
           @current_comment_token_query ||=

data/lib/yoda/{evaluation → services}/comment_completion/param_provider.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Evaluation
+  module Services
     class CommentCompletion
       # @note WIP
       class ParamProvider < BaseProvider

data/lib/yoda/{evaluation → services}/comment_completion/tag_provider.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Evaluation
+  module Services
     class CommentCompletion
       class TagProvider < BaseProvider
         # @return [true, false]

data/lib/yoda/{evaluation → services}/comment_completion/type_provider.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Evaluation
+  module Services
     class CommentCompletion
       class TypeProvider < BaseProvider
         # @return [true, false]
@@ -17,8 +17,9 @@ module Yoda
         # @return [Array<Model::Descriptions::Base>]
         def description_candidates
           return [] unless available?
+          return [] unless namespace
           scoped_path = Model::ScopedPath.new(lexical_scope(namespace), index_word)
-          Store::Query::FindConstant.new(registry).select_with_prefix(scoped_path).map { |obj| Model::Descriptions::ValueDescription.new(obj) }
+          Store::Query::FindConstant.new(environment.registry).select_with_prefix(scoped_path).map { |obj| Model::Descriptions::ValueDescription.new(obj) }
         end
 
         # @return [Parsing::Range, nil]
@@ -42,15 +43,15 @@ module Yoda
           current_comment_token_query.at_sign? ? '' : current_comment_token_query.current_word
         end
 
-        # @return [Parsing::NodeObjects::Namespace, nil]
+        # @return [AST::Namespace, nil]
         def namespace
           current_commenting_node_query.current_namespace
         end
 
-        # @param namespace [Parsing::NodeObjects::Namespace]
+        # @param namespace [AST::Namespace]
         # @return [Array<Path>]
         def lexical_scope(namespace)
-          namespace.paths_from_root.reverse.map { |name| Model::Path.build(name.empty? ? 'Object' : name.gsub(/\A::/, '')) }
+          evaluator.node_info(namespace).lexical_scope_types.reverse.flat_map { |type| type.value.referred_objects.map(&:path) }
         end
       end
     end