yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/instrument.rb

@@ -1,4 +1,5 @@
 require 'concurrent'
+require 'forwardable'
 
 module Yoda
   class Instrument
@@ -25,8 +26,8 @@ module Yoda
         instrument.unsubscribe(self)
       end
 
-      def call(params)
-        callback.call(params)
+      def call(*params, **kwargs)
+        callback.call(*params, **kwargs)
       end
     end
 
@@ -60,12 +61,20 @@ module Yoda
     attr_reader :subscriptions
 
     class << self
+      extend Forwardable
+
+      delegate %i(hear subscribe emit unsubscribe) => :instance
+
       # Returns Instrument instance (thread local).
       # @return [Instrument]
       def instance
         local.value
       end
 
+      def clean
+        local.value = Instrument.new
+      end
+
       private
 
       # @return [Concurrent::ThreadLocalVar<Instrument>]
@@ -95,10 +104,10 @@ module Yoda
     end
 
     # @param name [String]
-    # @param [String]
-    def emit(name, params)
+    # @param params [Hash]
+    def emit(name, **params)
       Logger.trace("#{name}: #{params}")
-      subscriptions.select { |subscription| subscription.name === name }.each { |subscription| subscription.call(params) }
+      subscriptions.select { |subscription| subscription.name === name }.each { |subscription| subscription.call(**params) }
     end
 
     # @param subscription [Subscription]

data/lib/yoda/logger.rb

@@ -20,10 +20,12 @@ module Yoda
       #   @!method allow_$1?
       #     @return [true, false]
       def define_logging_method(level)
-        define_method(level) do |content, tag: nil|
+        define_method(level) do |content = nil, tag: nil|
           return unless public_send("allow_#{level}?")
+          content = yield if block_given?
+          content ||= ""
           prefix = "[#{level}]#{tag ? ' (' + tag + ')' : '' } "
-          io.puts(prefix + content.to_s.split("\n").join(prefix))
+          io.puts(prefix + content.to_s.lines.join(prefix))
         end
 
         define_method("allow_#{level}?") do

data/lib/yoda/missing_delegatable.rb

@@ -0,0 +1,34 @@
+module Yoda
+  module MissingDelegatable
+    module ClassMethods
+      # @return [Symbol, nil]
+      attr_reader :delegate_missing_target
+
+      # @param target [Symbol] the delegation target if an missing method is passed.
+      def delegate_missing(target)
+        @delegate_missing_target = target
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private)
+      delegate_missing_target&.respond_to?(method_name, include_private) || super
+    end
+
+    def method_missing(method_name, *args, &blk)
+      if delegate_missing_target&.respond_to?(method_name)
+        delegate_missing_target.public_send(method_name, *args, &blk)
+      else
+        super
+      end
+    end
+
+    # @return [Object, nil]
+    def delegate_missing_target
+      self.class.delegate_missing_target && send(self.class.delegate_missing_target)
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+  end
+end

data/lib/yoda/model/completion_item.rb

@@ -1,8 +1,10 @@
 module Yoda
   module Model
     class CompletionItem
-      # @return [Descriptions::Base]
-      attr_reader :description
+      extend Forwardable
+
+      # @return [Array<Descriptions::Base>]
+      attr_reader :descriptions
 
       # @return [Parsing::Range]
       attr_reader :range
@@ -13,30 +15,38 @@ module Yoda
       # @return [String]
       attr_reader :prefix
 
-      # @param description [Descriptions::Base]
-      # @param range       [Parsing::Range]
-      # @param kind        [Symbol, nil]
-      # @param prefix      [String, nil]
-      def initialize(description:, range:, kind: nil, prefix: nil)
-        fail ArgumentError, desctiption unless description.is_a?(Descriptions::Base)
+      delegate %i(label title to_markdown sort_text) => :primary_description
+
+      # @param descriptions [Array<Descriptions::Base>]
+      # @param range        [Parsing::Range]
+      # @param kind         [Symbol, nil]
+      # @param prefix       [String, nil]
+      def initialize(description: nil, descriptions: [], range:, kind: nil, prefix: nil)
+        fail ArgumentError, description if description && !description.is_a?(Descriptions::Base)
+        fail ArgumentError, descriptions unless descriptions.all? { |description| description.is_a?(Descriptions::Base) }
         fail ArgumentError, range unless range.is_a?(Parsing::Range)
         fail ArgumentError, kind if !kind.nil? && !available_kinds.include?(kind)
-        @description = description
+        @descriptions = ([description] + descriptions).compact
         @range = range
         @kind = kind
         @prefix = prefix || ''
       end
 
+      def primary_description
+        descriptions.first
+      end
+
       # @return [String]
       def edit_text
-        prefix + description.sort_text
+        prefix + primary_description.sort_text
       end
 
       # @return [Symbol]
       def available_kinds
-        %i(method class module constant)
+        %i(method class module constant variable)
       end
 
+      # @return [Symbol]
       def language_server_kind
         case kind
         when :constant
@@ -47,10 +57,32 @@ module Yoda
           LanguageServer::Protocol::Constant::CompletionItemKind::CLASS
         when :module
           LanguageServer::Protocol::Constant::CompletionItemKind::MODULE
+        when :variable
+          LanguageServer::Protocol::Constant::CompletionItemKind::VARIABLE
         else
           nil
         end
       end
+
+      def to_s
+        title
+      end
+
+      # @return [{Symbol => { Symbol => Integer } }]
+      def language_server_range
+        range.to_language_server_protocol_range
+      end
+
+      # @param function_description [FunctionDescription]
+      # @return [FunctionDescription, MultipleFunctionDescription]
+      def merge(completion_item)
+        self.class.new(
+          descriptions: descriptions + completion_item.descriptions,
+          range: range,
+          kind: kind,
+          prefix: prefix,
+        )
+      end
     end
   end
 end

data/lib/yoda/model/descriptions/base.rb

@@ -15,11 +15,22 @@ module Yoda
           fail NotImplementedError
         end
 
+        # @return [String]
+        def label
+          sort_text
+        end
+
         # @abstract
         # @return [String]
         def to_markdown
           fail NotImplementedError
         end
+
+        # Return an LSP MarkedString content for description
+        # @return [String, Hash]
+        def markup_content
+          to_markdown
+        end
       end
     end
   end

data/lib/yoda/model/descriptions/comment_token_description.rb

@@ -0,0 +1,46 @@
+module Yoda
+  module Model
+    module Descriptions
+      class CommentTokenDescription < Base
+        # @return [AST::CommentBlock::Token]
+        attr_reader :comment_token
+
+        # @return [TypeExpressions::Base]
+        attr_reader :type
+
+        # @param comment_token [AST::CommentBlock::Token]
+        # @param type [TypeExpressions::Base]
+        def initialize(comment_token, type)
+          @comment_token = comment_token
+          @type = type
+        end
+
+        # @return [String]
+        def title
+          comment_token.content
+        end
+
+        # @return [String]
+        def sort_text
+          comment_token.content
+        end
+
+        # @return [String]
+        def to_markdown
+          <<~EOS
+          **#{title}**
+
+          #{value.document}
+          EOS
+        end
+
+        def markup_content
+          {
+            language: 'ruby',
+            value: "#{title.gsub("\n", ";")} # #{type}",
+          }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/descriptions/function_description.rb

@@ -2,12 +2,12 @@ module Yoda
   module Model
     module Descriptions
       class FunctionDescription < Base
-        # @type Store::Objects::MethodObject
+        # @return [FunctionSignatures::Base]
         attr_reader :function
 
         # @param function [FunctionSignatures::Base]
         def initialize(function)
-          fail ArgumentError, function unless function.is_a?(FunctionSignatures::Base)
+          fail ArgumentError, function unless function.is_a?(FunctionSignatures::Wrapper)
           @function = function
         end
 
@@ -15,6 +15,10 @@ module Yoda
           "#{function.namespace_path}#{function.sep}#{function.to_s}"
         end
 
+        def label
+          signature
+        end
+
         def signature
           "#{function.to_s}"
         end
@@ -32,8 +36,21 @@ module Yoda
           **#{title}**
 
           #{function.document}
+          #{tag_documents}
           EOS
         end
+
+        private
+
+        def tag_documents
+          function.tags.map do |tag|
+            str = "@#{tag.tag_name}"
+            str += " `#{tag.name}`" if tag.name
+            str += " [#{tag.yard_types.map { |name| "`#{name}`" }.join(', ')}]" if tag.yard_types && !(tag.yard_types.empty?)
+            str += " #{tag.text.chomp}" if tag.text
+            str
+          end.join("  \n") # Commonmark requires 2 spaces for line breaking
+        end
       end
     end
   end

data/lib/yoda/model/descriptions/node_description.rb

@@ -7,14 +7,14 @@ module Yoda
         # @return [::Parser::AST::Node]
         attr_reader :node
 
-        # @return [Typing::Traces::Base]
-        attr_reader :trace
+        # @return [TypeExpressions::Base]
+        attr_reader :type
 
-        # @param node  [::Parser::AST::Node]
-        # @param trace [Typing::Traces::Base]
-        def initialize(node, trace)
+        # @param node  [AST::Vnode]
+        # @param type [TypeExpressions::Base]
+        def initialize(node, type)
           @node = node
-          @trace = trace
+          @type = type
         end
 
         # @return [String]
@@ -30,15 +30,26 @@ module Yoda
         # @return [String]
         def to_markdown
           <<~EOS
-          #{node_body.gsub("\n", ";")}: #{trace.type}
+          #{node_body.gsub("\n", ";")}: #{type}
           EOS
         end
 
+        def markup_content
+          {
+            language: 'ruby',
+            value: "#{node_body.gsub("\n", ";")} # #{type}",
+          }
+        end
+
         private
 
         # @return [String]
         def node_body
-          @node_body ||= Unparser.unparse(node)
+          @node_body ||= begin
+            if node.respond_to?(:node)
+              Unparser.unparse(node.node)
+            end
+          end
         end
       end
     end

data/lib/yoda/model/descriptions/variable_description.rb

@@ -0,0 +1,41 @@
+module Yoda
+  module Model
+    module Descriptions
+      class VariableDescription < Base
+        # @return [Symbol]
+        attr_reader :variable
+
+        # @return [TypeExpressions::Base]
+        attr_reader :type
+
+        # @param variable [Symbol]
+        # @param type [TypeExpressions::Base]
+        def initialize(variable:, type:)
+          @variable = variable
+          @type = type
+        end
+
+        # @return [String]
+        def title
+          "#{variable}: #{type}"
+        end
+
+        # @return [String]
+        def sort_text
+          variable.to_s
+        end
+
+        def to_markdown
+          ""
+        end
+
+        def markup_content
+          {
+            language: 'ruby',
+            value: "#{variable} # #{type}",
+          }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/descriptions.rb

@@ -2,10 +2,12 @@ module Yoda
   module Model
     module Descriptions
       require 'yoda/model/descriptions/base'
+      require 'yoda/model/descriptions/comment_token_description'
       require 'yoda/model/descriptions/function_description'
       require 'yoda/model/descriptions/value_description'
       require 'yoda/model/descriptions/word_description'
       require 'yoda/model/descriptions/node_description'
+      require 'yoda/model/descriptions/variable_description'
     end
   end
 end

data/lib/yoda/model/environment/accessor_interface.rb

@@ -0,0 +1,43 @@
+module Yoda
+  module Model
+    class Environment
+      module AccessorInterface
+        # @abstract
+        # @return [Store::Objects::NamespaceObject::Connected, nil]
+        def self_object
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Store::Objects::NamespaceObject::Connected, nil]
+        def class_object
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [RBS::Definition, nil]
+        def rbs_definition
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [NamespaceMembers]
+        def members
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [SingletonAccessor]
+        def singleton_accessor
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [AccessorInterface, nil]
+        def instance_accessor
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/environment/instance_accessor.rb

@@ -0,0 +1,121 @@
+require 'yoda/model/environment/accessor_interface'
+require 'yoda/model/environment/with_cache'
+
+module Yoda
+  module Model
+    class Environment
+      class InstanceAccessor
+        include AccessorInterface
+        include WithCache
+
+        # @return [Environment]
+        attr_reader :environment
+
+        # @return [String, Path]
+        attr_reader :path
+
+        # @return [RBS::Types::t]
+        attr_reader :type_args
+
+        # @param environment [Environment]
+        # @param path [String, Path]
+        # @param type_args [Array<RBS::Types::t>]
+        def initialize(environment:, path:, type_args:)
+          @environment = environment
+          @path = path
+          @type_args = type_args
+        end
+
+        # @return [NamespaceMembers]
+        def members
+          @members ||= NamespaceMembers.new(accessor: self, environment: environment)
+        end
+
+        # @return [Store::Objects::NamespaceObject::Connected, nil]
+        def class_object
+          with_cache(:class_object) do
+            object = environment.resolve_constant(path)&.with_connection(registry: environment.registry)
+            object&.namespace? ? object : nil
+          end
+        end
+
+        # @return [Store::Objects::NamespaceObject::Connected, nil]
+        def self_object
+          with_cache(:self_object) do
+            if class_object&.kind == :meta_class
+              class_object.instance
+            else
+              nil
+            end
+          end
+        end
+
+        # @return [nil]
+        def instance_accessor
+          nil
+        end
+
+        # @return [SingletonAccessor]
+        def singleton_accessor
+          SingletonAccessor.new(self)
+        end
+
+        # @return [RBS::Definition, nil]
+        def rbs_definition
+          with_cache(:rbs_definition) do
+            if rbs_class_decl
+              builder = RBS::DefinitionBuilder.new(env: environment.rbs_environment)
+              builder.build_instance(type_name).sub(substitution)
+            elsif rbs_interface_decl
+              builder = RBS::DefinitionBuilder.new(env: environment.rbs_environment)
+              builder.build_interface(type_name).sub(substitution)
+            else
+              nil
+            end
+          end
+        end
+
+        # @param return [RBS::AST::Declarations::Class, nil]
+        def rbs_class_decl
+          with_cache(:rbs_class_decl) do
+            environment.resolve_rbs_class_decl(type_name)
+          end
+        end
+
+        # @param return [RBS::AST::Declarations::Interface, nil]
+        def rbs_interface_decl
+          with_cache(:rbs_interface_decl) do
+            environment.resolve_rbs_interface_decl(type_name)
+          end
+        end
+
+        # @return [RBS::TypeName]
+        def type_name
+          @type_name ||= TypeName(path.to_s)
+        end
+
+        def rbs_definition_builder
+          @rbs_definition_builder ||= RBS::DefinitionBuilder.new(env: environment.rbs_environment)
+        end
+
+        private
+
+        # @return [RBS::Substitution, nil]
+        def substitution
+          with_cache(:substitution) do
+            decl = rbs_class_decl || rbs_interface_decl
+
+            if decl
+              length = decl.type_params.length
+              types = length.times.map { |i| type_args[i] || RBS::Types::Bases::Any.new(location: nil) }
+              RBS::Substitution.build(
+                decl.type_params.map(&:name),
+                types,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/environment/namespace_members.rb

@@ -0,0 +1,104 @@
+require 'forwardable'
+
+module Yoda
+  module Model
+    class Environment
+      class NamespaceMembers
+        # @return [AccessorInterface]
+        attr_reader :accessor
+
+        # @return [Environment]
+        attr_reader :environment
+
+        # @param accessor [AccessorInterface]
+        # @param environment [Environment]
+        def initialize(accessor:, environment:)
+          @accessor = accessor
+          @environment = environment
+        end
+
+        # @param name [String, Symbol, Regexp]
+        # @param visibility [Array<:private, :public, :protected>]
+        # @return [Enumerator<FunctionSignatures::Base>]
+        def select_method(name, visibility:)
+          rbs_method_signatures = begin
+            method_defs = filter_rbs_methods(name, visibility: visibility)
+            method_defs.flat_map do |method_def|
+              method_def.defs.map do |type_def|
+                FunctionSignatures::RbsMethod.new(
+                  rbs_definition: accessor.rbs_definition,
+                  rbs_method_definition: method_def,
+                  rbs_method_typedef: type_def,
+                )
+              end
+            end
+          end
+
+          stored_signatures = stored_method_members&.select_signature(name, visibility: visibility) || []
+
+          (rbs_method_signatures + stored_signatures).map { |sig| sig.wrap(environment) }
+        end
+
+        # @param name [String, Symbol]
+        # @return [Array<Symbol>]
+        def select_constant_paths(name, **)
+          # TODO: Search RBS
+          stored_consts = stored_constant_members&.select(name) || []
+          stored_consts.map(&:path)
+        end
+
+        # @param name [String, Symbol]
+        # @return [RBS::Types::t]
+        def select_constant_type(name, **)
+          paths = select_constant_paths(name)
+
+          types = paths.flat_map do |path|
+            name = accessor.environment.resolve_rbs_type_name(path)
+            name && RBS::Types::ClassSingleton.new(
+              name: name,
+              location: nil,
+            )
+          end.compact
+
+          if types.empty?
+            RBS::Types::Bases::Any.new(location: nil)
+          else
+            RBS::Types::Union.new(types: types, location: nil)
+          end
+        end
+
+        private
+
+        # @param pattern [String, Symbol, Regexp]
+        # @param visibility [Array<:private, :public, :protected>]
+        # @return [Array<RBS::Definition::Method>]
+        def filter_rbs_methods(pattern, visibility:)
+          return [] unless rbs_methods
+          if pattern.is_a?(Regexp)
+            rbs_methods.select do |key, value|
+              key.to_s.match?(pattern) && visibility.include?(value.accessibility)
+            end.map { |(key, value)| value }
+          else
+            meth = rbs_methods[pattern.to_sym]
+            meth && visibility.include?(meth.accessibility) ? [meth] : []
+          end
+        end
+
+        # @return [Hash<Symbol => RBS::Definition::Method>]
+        def rbs_methods
+          accessor.rbs_definition&.methods
+        end
+
+        # @return [Store::Query::MethodMemberSet, nil]
+        def stored_method_members
+          accessor.class_object&.method_members
+        end
+
+        # @return [Store::Query::ConstantMemberSet, nil]
+        def stored_constant_members
+          accessor.self_object&.constant_members
+        end
+      end
+    end
+  end
+end