yoda-language-server 0.7.2 → 0.10.0

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

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

@@ -1,13 +1,13 @@
 module Yoda
-  module Evaluation
+  module Services
     class CommentCompletion
-      require 'yoda/evaluation/comment_completion/base_provider'
-      require 'yoda/evaluation/comment_completion/param_provider'
-      require 'yoda/evaluation/comment_completion/tag_provider'
-      require 'yoda/evaluation/comment_completion/type_provider'
+      require 'yoda/services/comment_completion/base_provider'
+      require 'yoda/services/comment_completion/param_provider'
+      require 'yoda/services/comment_completion/tag_provider'
+      require 'yoda/services/comment_completion/type_provider'
 
-      # @type Store::Registry
-      attr_reader :registry
+      # @return [Model::Environment]
+      attr_reader :environment
 
       # @type ::Parser::AST::Node
       attr_reader :ast
@@ -18,12 +18,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
@@ -48,17 +48,17 @@ module Yoda
 
       # @return [ParamProvider]
       def param_provider
-        @param_provider ||= ParamProvider.new(registry, ast, comments, location)
+        @param_provider ||= ParamProvider.new(environment, ast, comments, location)
       end
 
       # @return [TagProvider]
       def tag_provider
-        @tag_provider ||= TagProvider.new(registry, ast, comments, location)
+        @tag_provider ||= TagProvider.new(environment, ast, comments, location)
       end
 
       # @return [TypeProvider]
       def type_provider
-        @type_provider ||= TypeProvider.new(registry, ast, comments, location)
+        @type_provider ||= TypeProvider.new(environment, ast, comments, location)
       end
 
       def comment?

data/lib/yoda/services/current_node_explain/comment_signature.rb

@@ -0,0 +1,77 @@
+module Yoda
+  module Services
+    class CurrentNodeExplain
+      class CommentSignature
+        # @return [AST::CommentBlock]
+        attr_reader :comment
+
+        # @return [Parsing::Location]
+        attr_reader :location
+
+        # @return [Typing::NodeInfo]
+        attr_reader :node_info
+
+        # @param comment [AST::CommentBlock]
+        # @param location [Parsing::Location]
+        # @param node_info [Typing::NodeInfo]
+        def initialize(comment:, location:, node_info:)
+          @comment = comment
+          @location = location
+          @node_info = node_info
+        end
+
+        # @return [Boolean]
+        def providable?
+          node_range
+        end
+
+        # @return [Range, nil]
+        def node_range
+          current_comment_token&.range
+        end
+
+        # @return [Array<Model::Descriptions::Base>]
+        def descriptions
+          [node_type_description, *type_descriptions].compact
+        end
+
+        # @return [Array<String>]
+        def defined_files
+          objects.map { |value| Model::PrimarySourceInferencer.new.infer_for_object(value) }.compact
+        end
+
+        # @return [Model::Descriptions::Base, nil]
+        def node_type_description
+          if constants_type
+            Model::Descriptions::CommentTokenDescription.new(current_comment_token, constants_type)
+          end
+        end
+
+        # @return [Array<Descriptions::Base>]
+        def type_descriptions
+          objects.map { |object| Model::Descriptions::ValueDescription.new(object) }
+        end
+
+        private
+
+        # @return [Array<Store::Objects::Base>]
+        def objects
+          constants_type&.value&.referred_objects || []
+        end
+
+        # @return [AST::CommentBlock::Token, nil]
+        def current_comment_token
+          part = comment.nearest_tag_part(location)
+          part&.type_part&.nearest_token(location)
+        end
+
+        # @return [Typing::Types::Type, nil]
+        def constants_type
+          @constants_type ||= begin
+            current_comment_token && node_info.resolve_constant(current_comment_token.content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/services/current_node_explain.rb

@@ -0,0 +1,72 @@
+module Yoda
+  module Services
+    # CurrentNodeExplain shows help for the current node.
+    class CurrentNodeExplain
+      require 'yoda/services/current_node_explain/comment_signature'
+
+      # @return [Evaluator]
+      attr_reader :evaluator
+
+      # @return [Parsing::Location]
+      attr_reader :location
+
+      # @param environment [Model::Environment]
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      # @return [CurrentNodeExplain]
+      def self.from_source(environment:, source:, location:)
+        ast, _ = Parsing.parse_with_comments(source)
+        new(
+          evaluator: Evaluator.new(environment: environment, ast: ast),
+          location: location
+        )
+      end
+
+      # @param evaluator [Evaluator]
+      # @param location [Parsing::Location]
+      def initialize(evaluator:, location:)
+        @evaluator = evaluator
+        @location = location
+      end
+
+      # @return [Model::NodeSignature, nil]
+      def current_node_signature
+        return nil if !valid? || !current_node
+        @current_node_signature ||= Model::NodeSignatures.for_node_info(current_node_info)
+      end
+
+      # @return [CommentSignature, nil]
+      def current_comment_signature
+        return nil if !valid? || !current_comment || !commenting_node_info
+        @current_comment_signature ||= CommentSignature.new(comment: current_comment, node_info: commenting_node_info, location: location)
+      end
+
+      # @return [true, false]
+      def valid?
+        !!(current_comment || current_node)
+      end
+
+      private
+
+      # @return [Typing::NodeInfo]
+      def current_node_info
+        @current_node_info ||= evaluator.node_info(current_node)
+      end
+
+      # @return [Typing::NodeInfo]
+      def commenting_node_info
+        @commenting_node_info ||= current_comment&.node ? evaluator.node_info(current_comment&.node) : nil
+      end
+
+      # @return [Parser::AST::Node]
+      def current_node
+        @current_node ||= evaluator.ast.positionally_nearest_child(location)
+      end
+
+      # @return [AST::CommentBlock, nil]
+      def current_comment
+        @current_comment || evaluator.ast.positionally_nearest_comment(location)
+      end
+    end
+  end
+end