yoda-language-server 0.4.0

data/lib/yoda/evaluation/code_completion/method_provider.rb

@@ -0,0 +1,82 @@
+module Yoda
+  module Evaluation
+    class CodeCompletion
+      class MethodProvider < BaseProvider
+        # @return [true, false]
+        def providable?
+          !!(current_send)
+        end
+
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          method_candidates.map do |method_candidate|
+            Model::CompletionItem.new(
+              description: Model::Descriptions::FunctionDescription.new(method_candidate),
+              range: substitution_range,
+              kind: :method,
+            )
+          end
+        end
+
+        private
+
+        # @return [Range]
+        def substitution_range
+          return current_send.selector_range if current_send.on_selector?(location)
+          return Parsing::Range.new(current_send.next_location_to_dot, current_send.next_location_to_dot) if current_send.on_dot?(location)
+          nil
+        end
+
+        # @return [Array<Store::Objects::Method>]
+        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
+        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
+            %i(public private protected)
+          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
+        end
+
+        # @return [Parsing::NodeObjects::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
+        end
+
+        # @return [String, nil]
+        def index_word
+          return nil unless providable?
+          @index_word ||= current_send.on_selector?(location) ? current_send.selector_name.slice(0..current_send.offset_in_selector(location)) : ''
+        end
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/code_completion/variable_provider.rb

@@ -0,0 +1,18 @@
+module Yoda
+  module Evaluation
+    class CodeCompletion
+      # WIP
+      class VariableProvider < BaseProvider
+        # @return [true, false]
+        def providable?
+          false
+        end
+
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          []
+        end
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/comment_completion.rb

@@ -0,0 +1,70 @@
+module Yoda
+  module Evaluation
+    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'
+
+      # @type Store::Registry
+      attr_reader :registry
+
+      # @type ::Parser::AST::Node
+      attr_reader :ast
+
+      # @type Array<::Parser::Source::Comment>
+      attr_reader :comments
+
+      # @type Location
+      attr_reader :location
+
+      # @param registry [Store::Registry]
+      # @param ast      [::Parser::AST::Node]
+      # @param comments [Array<::Parser::Source::Comment>]
+      # @param location [Location]
+      def initialize(registry, ast, comments, location)
+        @registry = registry
+        @ast = ast
+        @comments = comments
+        @location = location
+      end
+
+      # @return [true, false]
+      def available?
+        comment? && providers.any?(&:available?)
+      end
+
+      # @return [Array<Model::CompletionItem>]
+      def candidates
+        available? ? providers.select(&:available?).map(&:candidates).flatten : []
+      end
+
+      private
+
+      # @return [Array<CommentCompletion::BaseProvider>]
+      def providers
+        [param_provider, tag_provider, type_provider]
+      end
+
+      # @return [ParamProvider]
+      def param_provider
+        @param_provider ||= ParamProvider.new(registry, ast, comments, location)
+      end
+
+      # @return [TagProvider]
+      def tag_provider
+        @tag_provider ||= TagProvider.new(registry, ast, comments, location)
+      end
+
+      # @return [TypeProvider]
+      def type_provider
+        @type_provider ||= TypeProvider.new(registry, ast, comments, location)
+      end
+
+      def comment?
+        return @is_comment if instance_variable_defined?(:@is_comment)
+        @is_comment = !!Parsing::Query::CurrentCommentQuery.new(comments, location).current_comment
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/comment_completion/base_provider.rb

@@ -0,0 +1,64 @@
+module Yoda
+  module Evaluation
+    class CommentCompletion
+      # @abstract
+      class BaseProvider
+        # @type Store::Registry
+        attr_reader :registry
+
+        # @type ::Parser::AST::Node
+        attr_reader :ast
+
+        # @type Array<::Parser::Source::Comment>
+        attr_reader :comments
+
+        # @type Location
+        attr_reader :location
+
+        # @param registry [Store::Registry]
+        # @param ast      [::Parser::AST::Node]
+        # @param comments [Array<::Parser::Source::Comment>]
+        # @param location [Location]
+        def initialize(registry, ast, comments, location)
+          @registry = registry
+          @ast = ast
+          @comments = comments
+          @location = location
+        end
+
+        # @abstract
+        # @return [true, false]
+        def available?
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          fail NotImplementedError
+        end
+
+        private
+
+        # @return [Parsing::Query::CurrentCommentTokenQuery]
+        def current_comment_token_query
+          @current_comment_token_query ||=
+            Parsing::Query::CurrentCommentTokenQuery.new(
+              current_comment_query.current_comment_block_text,
+              current_comment_query.location_in_current_comment_block,
+            )
+        end
+
+        # @return [Parsing::Query::CurrentCommentQuery]
+        def current_comment_query
+          @current_comment_query ||= Parsing::Query::CurrentCommentQuery.new(comments, location)
+        end
+
+        # @return [CurrentCommentingNodeQuery]
+        def current_commenting_node_query
+          Parsing::Query::CurrentCommentingNodeQuery.new(ast, comments, location)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/comment_completion/param_provider.rb

@@ -0,0 +1,18 @@
+module Yoda
+  module Evaluation
+    class CommentCompletion
+      # @note WIP
+      class ParamProvider < BaseProvider
+        # @return [true, false]
+        def available?
+          current_comment_token_query.current_state == :param
+        end
+
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          []
+        end
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/comment_completion/tag_provider.rb

@@ -0,0 +1,41 @@
+module Yoda
+  module Evaluation
+    class CommentCompletion
+      class TagProvider < BaseProvider
+        # @return [true, false]
+        def available?
+          current_comment_token_query.current_state == :tag
+        end
+
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          description_candidates.map { |description| Model::CompletionItem.new(description: description, range: substitution_range) }
+        end
+
+        private
+
+        # @return [Array<Model::Descriptions::WordDescription>]
+        def description_candidates
+          return [] unless available?
+          tagnames.select { |tagname| tagname.start_with?(index_word) }.map { |obj| Model::Descriptions::WordDescription.new(obj) }
+        end
+
+        # @return [Parsing::Range, nil]
+        def substitution_range
+          return nil unless available?
+          current_comment_query.absolute_range(current_comment_token_query.current_range)
+        end
+
+        # @return [String]
+        def index_word
+          current_comment_token_query.current_word
+        end
+
+        # @return [Array<String>]
+        def tagnames
+          @tagnames ||= YARD::Tags::Library.labels.map { |tag_symbol, label| "@#{tag_symbol}" }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/comment_completion/type_provider.rb

@@ -0,0 +1,58 @@
+module Yoda
+  module Evaluation
+    class CommentCompletion
+      class TypeProvider < BaseProvider
+        # @return [true, false]
+        def available?
+          [:type, :type_tag_type].include?(current_comment_token_query.current_state)
+        end
+
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          description_candidates.map { |description| Model::CompletionItem.new(description: description, range: substitution_range) }
+        end
+
+        private
+
+        # @return [Array<Model::Descriptions::Base>]
+        def description_candidates
+          return [] unless available?
+          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) }
+        end
+
+        # @return [Parsing::Range, nil]
+        def substitution_range
+          return nil unless available?
+          # @todo Move this routine to Parsing module
+          if current_comment_token_query.current_range
+            range = current_comment_token_query.current_range.move(
+              row: current_comment_query.begin_point_of_current_comment_block.row - 1,
+              column: current_comment_query.begin_point_of_current_comment_block.column,
+            )
+            cut_point = current_comment_token_query.at_sign? ? 1 : (current_comment_token_query.current_word.rindex('::') || -2) + 2
+            Parsing::Range.new(range.begin_location.move(row: 0, column: cut_point), range.end_location)
+          else
+            Parsing::Range.new(location, location)
+          end
+        end
+
+        # @return [String]
+        def index_word
+          current_comment_token_query.at_sign? ? '' : current_comment_token_query.current_word
+        end
+
+        # @return [Parsing::NodeObjects::Namespace, nil]
+        def namespace
+          current_commenting_node_query.current_namespace
+        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::/, '')) }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/current_node_explain.rb

@@ -0,0 +1,70 @@
+module Yoda
+  module Evaluation
+    class CurrentNodeExplain
+      # @return [Store::Registry]
+      attr_reader :registry
+
+      # @return [String]
+      attr_reader :source
+
+      # @return [Parsing::Location]
+      attr_reader :location
+
+      # @param registry [Store::Registry]
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      def initialize(registry, source, location)
+        @registry = registry
+        @source = source
+        @location = location
+      end
+
+      # @return [Model::NodeSignature, nil]
+      def current_node_signature
+        return nil if !valid? || !current_node_trace
+        @current_node_signature ||= Model::NodeSignature.new(current_node, current_node_trace)
+      end
+
+      # @return [true, false]
+      def valid?
+        !!(current_node)
+      end
+
+      # @return [Array<(String, Integer, Integer)>]
+      def defined_files
+        return [] if !valid? || !current_node_trace
+        case current_node.type
+        when :send
+          current_node_trace.functions.map { |function| function.primary_source }.compact
+        when :const
+          current_node_trace.values.map { |value| value.primary_source || value.sources.first }.compact
+        else
+          []
+        end
+      end
+
+      private
+
+      # @return [Typing::Traces::Base, nil]
+      def current_node_trace
+        return nil unless valid?
+        @current_node_trace ||= evaluator.calculate_trace(current_node)
+      end
+
+      # @return [Parser::AST::Node]
+      def current_node
+        analyzer.nodes_to_current_location_from_root.last
+      end
+
+      # @return [Evaluator]
+      def evaluator
+        @evaluator ||= Evaluator.from_ast(registry, analyzer.ast, location)
+      end
+
+      # @return [SourceAnalyzer]
+      def analyzer
+        @analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/evaluator.rb

@@ -0,0 +1,103 @@
+module Yoda
+  module Evaluation
+    class Evaluator
+      # @return [Parsing::Scopes::Base]
+      attr_reader :scope
+
+      # @return [Store::Registry]
+      attr_reader :registry
+
+      # @param registry [Store::Registry]
+      # @param ast [Parser::AST::Node]
+      # @param location [Parsing::Location]
+      # @return [Evaluator]
+      def self.from_ast(registry, ast, location)
+        from_root_scope(registry, Parsing::Scopes::Builder.new(ast).root_scope, location)
+      end
+
+      # @param registry [Store::Registry]
+      # @param root_scope [Parsing::Scopes::Root]
+      # @param location [Parsing::Location]
+      # @return [Evaluator]
+      def self.from_root_scope(registry, root_scope, location)
+        new(registry, root_scope.find_evaluation_root_scope(location) || root_scope)
+      end
+
+      # @param registry [Store::Registry]
+      # @param scope [Parsing::Scopes::Base]
+      def initialize(registry, scope)
+        @registry = registry
+        @scope = scope
+      end
+
+      # @param code_node   [::Parser::AST::Node]
+      # @return [Model::Types::Base, nil]
+      def calculate_type(code_node)
+        calculate_trace(code_node)&.type
+      end
+
+      # @param code_node   [::Parser::AST::Node]
+      # @return [Array<Store::Objects::Base>]
+      def calculate_values(code_node)
+        trace = calculate_trace(code_node)
+        trace ? trace.values : []
+      end
+
+      # @param code_node   [::Parser::AST::Node, nil]
+      # @return [Typing::Traces::Base, nil]
+      def calculate_trace(code_node)
+        return nil unless code_node
+        evaluate
+        evaluator.find_trace(code_node)
+      end
+
+      # @return [Store::Objects::Base, nil]
+      def scope_constant
+        @scope_constant ||= begin
+          Store::Query::FindConstant.new(registry).find(scope.scope_name)
+        end
+      end
+
+      private
+
+      def evaluate
+        unless @evaluated
+          evaluator.process(scope.body_node)
+          @evaluated = true
+        end
+      end
+
+      # @return [Typing::Evaluator]
+      def evaluator
+        @evaluator ||= Typing::Evaluator.new(evaluation_context)
+      end
+
+      # @return [Typing::Context]
+      def evaluation_context
+        @evaluation_context ||= begin
+          fail RuntimeError, "The namespace #{scope.scope_name} (#{scope}) is not registered" unless scope_constant
+          lexical_scope = Typing::LexicalScope.new(scope_constant, scope.ancestor_scopes)
+          context = Typing::Context.new(registry: registry, caller_object: receiver, lexical_scope: lexical_scope)
+          context.env.bind_method_parameters(current_method_signature) if current_method_signature
+          context
+        end
+      end
+
+      # @return [Model::FunctionSignatures::Base, nil]
+      def current_method_signature
+        return unless scope.kind == :method
+        @current_method_signature ||= Store::Query::FindSignature.new(registry).select(scope_constant, scope.name.to_s)&.first
+      end
+
+      def receiver
+        @receiver ||= begin
+          if scope.kind == :method
+            Store::Query::FindConstant.new(registry).find(scope.scope_name)
+          else
+            Store::Query::FindMetaClass.new(registry).find(scope.scope_name)
+          end
+        end
+      end
+    end
+  end
+end