yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/model/function_signatures/parameter_list.rb

@@ -5,6 +5,23 @@ module Yoda
         # @return [Array<(String, String)>]
         attr_reader :parameters
 
+        # @param type [RBS::MethodType]
+        def self.from_rbs_method_type(type)
+          func = type.type
+
+          parameters = []
+          parameters += func.required_positionals.map { |param| [param.name, ""] }
+          parameters += func.optional_positionals.map { |param| [param.name, ""] }
+          parameters += ["*#{type.rest_positionals.name}", ""] if func.rest_positionals
+          parameters += func.trailing_positionals.map { |param| [param.name, ""] }
+          parameters += func.required_keywords.map { |param| ["#{param.name}:", ""] }
+          parameters += func.optional_keywords.map { |param| ["#{param.name}:", ""] }
+          parameters += ["**#{func.rest_keywords.name}", ""] if func.rest_keywords
+          parameters += ["&block", ""] if type.block
+
+          new(parameters)
+        end
+
         # @param parameters [Array<(String, String)>]
         def initialize(parameters)
           fail ArgumentError, parameters unless parameters.all? { |param| param.is_a?(Array) }

data/lib/yoda/model/function_signatures/rbs_method.rb

@@ -0,0 +1,91 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      class RbsMethod < Base
+        # @return [RBS::Definition]
+        attr_reader :rbs_definition
+
+        # @return [RBS::Definition::Method]
+        attr_reader :rbs_method_definition
+
+        # @return [RBS::Definition::Method::TypeDef]
+        attr_reader :rbs_method_typedef
+
+        # @param rbs_definition [RBS::Definition]
+        # @param rbs_method_definition [RBS::Definition::Method]
+        # @param rbs_method_typedef [RBS::Definition::Method::TypeDef]
+        def initialize(rbs_definition:, rbs_method_definition:, rbs_method_typedef:)
+          @rbs_definition = rbs_definition
+          @rbs_method_definition = rbs_method_definition
+          @rbs_method_typedef = rbs_method_typedef
+        end
+
+        # @return [TypeExpressions::FunctionType]
+        def type
+          fail NotImplementedError
+        end
+
+        def sep
+          rbs_definition.instance_type? ? "#" : "."
+        end
+
+        # @return [RBS::MethodType]
+        def rbs_type(_env)
+          rbs_method_typedef.type
+        end
+
+        # @return [Symbol]
+        def visibility
+          rbs_method_definition.accessibility
+        end
+
+        # @return [String]
+        def name
+          rbs_method_typedef.member.name.to_s
+        end
+
+        # @return [String]
+        def namespace_path
+          rbs_definition.type_name.to_s
+        end
+
+        # @return [String]
+        def document
+          rbs_method_typedef.comment&.string || ""
+        end
+
+        # @return [Array<Store::Objects::Tag>]
+        def tags
+          []
+        end
+
+        # @abstract
+        # @return [ParameterList]
+        def parameters
+          ParameterList.from_rbs_method_type(rbs_method_typedef.type)
+        end
+
+        # @return [Array<(String, Integer, Integer)>]
+        def sources
+          location = rbs_method_typedef.comment.location
+          if location
+            [[location.name, *location.start_loc]]
+          else
+            []
+          end
+        end
+
+        # @return [String]
+        def to_s
+          "#{name}#{rbs_method_typedef.type.to_s}"
+        end
+
+        # @abstract
+        # @return [TypeExpressions::Base, nil]
+        def parameter_type_of(param)
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/function_signatures/type_builder.rb

@@ -1,6 +1,7 @@
 module Yoda
   module Model
     module FunctionSignatures
+      # TypeBuilder builds {TypeExpression::FunctionType} instance from YARD tags and parameter list.
       class TypeBuilder
         # @return [ParameterList]
         attr_reader :parameters
@@ -16,44 +17,50 @@ module Yoda
           @tag_list = tag_list
         end
 
-        # @return [Types::FunctionType]
+        # @return [TypeExpressions::FunctionType]
         def type
           @type ||= begin
             if !type_tags.empty?
               parsed_type = parse_type_tag(type_tags.first)
-              parsed_type.is_a?(Types::FunctionType) ? parsed_type : Types::FunctionType.new(return_type: parsed_type)
+              parsed_type.is_a?(TypeExpressions::FunctionType) ? parsed_type : TypeExpressions::FunctionType.new(return_type: parsed_type)
             else
-              Types::FunctionType.new(return_type: return_types.first || Types::UnknownType.new('nodoc'), **parameter_options)
+              TypeExpressions::FunctionType.new(return_type: return_types.first || TypeExpressions::UnknownType.new('nodoc'), **parameter_options)
             end
           end
         end
 
         # @param param [String]
-        # @return [Types::Base]
+        # @return [TypeExpressions::Base]
         def type_of(param)
-          param_type_table[param] || Types::UnknownType.new('nodoc')
+          param_type_table[param] || TypeExpressions::UnknownType.new('nodoc')
+        end
+
+        # @param param [String]
+        # @return [TypeExpressions::FunctionType::Parameter]
+        def parameter_of(name)
+          TypeExpressions::FunctionType::Parameter.new(name: name, type: type_of(name))
         end
 
         private
 
         # @param type_tag [Store::Objects::Tag]
-        # @return [Types::FunctionType]
+        # @return [TypeExpressions::FunctionType]
         def parse_type_tag(tag)
-          parsed_type = Parsing::TypeParser.new.safe_parse(tag.text).change_root(convert_lexical_scope_literals(tag.lexical_scope))
-          parsed_type.is_a?(Types::FunctionType) ? parsed_type : Types::FunctionType.new(return_type: parsed_type)
+          parsed_type = TypeParser.new(tag).type_of_type_tag
+          parsed_type.is_a?(TypeExpressions::FunctionType) ? parsed_type : TypeExpressions::FunctionType.new(return_type: parsed_type)
         end
 
         # @return [Hash]
         def parameter_options
           @parameter_options ||= {
-            required_parameters: parameters.required_parameters.map(&method(:type_of)),
-            optional_parameters: parameters.optional_parameters.map(&:first).map(&method(:type_of)),
-            rest_parameter: parameters.rest_parameter ? type_of(parameters.rest_parameter) : nil,
-            post_parameters: parameters.post_parameters.map(&method(:type_of)),
-            required_keyword_parameters: parameters.required_keyword_parameters.map(&method(:type_of)),
-            optional_keyword_parameters: parameters.optional_keyword_parameters.map(&:first).map(&method(:type_of)),
-            keyword_rest_parameter: parameters.keyword_rest_parameter ? type_of(parameters.keyword_rest_parameter) : nil,
-            block_parameter: parameters.block_parameter ? type_of(parameters.block_parameter) : nil,
+            required_parameters: parameters.required_parameters.map(&method(:parameter_of)),
+            optional_parameters: parameters.optional_parameters.map(&:first).map(&method(:parameter_of)),
+            rest_parameter: parameters.rest_parameter ? parameter_of(parameters.rest_parameter) : nil,
+            post_parameters: parameters.post_parameters.map(&method(:parameter_of)),
+            required_keyword_parameters: parameters.required_keyword_parameters.map(&method(:parameter_of)),
+            optional_keyword_parameters: parameters.optional_keyword_parameters.map(&:first).map(&method(:parameter_of)),
+            keyword_rest_parameter: parameters.keyword_rest_parameter ? parameter_of(parameters.keyword_rest_parameter) : nil,
+            block_parameter: parameters.block_parameter ? parameter_of(parameters.block_parameter) : nil,
           }
         end
 
@@ -72,28 +79,53 @@ module Yoda
           @param_tags ||= tag_list.select { |tag| tag.tag_name == 'param' }
         end
 
-        # @return [Array<Types::Base>]
+        # @return [Array<TypeExpressions::Base>]
         def return_types
-          @return_types ||= parse_yard_type_tags(return_tags)
-        end
-
-        # @param tags [Array<Store::Objects::Tag>]
-        # @return [Array<Types::Base>]
-        def parse_yard_type_tags(tags)
-          tags.map do |tag|
-            tag.yard_types.empty? ? Types::UnknownType.new('nodoc') : Types.parse_type_strings(tag.yard_types).change_root(convert_lexical_scope_literals(tag.lexical_scope))
+          @return_types ||= return_tags.map do |tag|
+            TypeParser.new(tag).type
           end
         end
 
-        # @return [{ String => Types::Base }]
+        # @return [{ String => TypeExpressions::Base }]
         def param_type_table
-          @param_type_table ||= param_tags.map(&:name).zip(parse_yard_type_tags(param_tags)).group_by(&:first).map { |k, v| [k, Types::UnionType.new(v.map(&:last))] }.to_h
+          @param_type_table ||= begin
+            param_types = param_tags.map { |tag| TypeParser.new(tag).type }
+
+            name_to_types = param_tags.map(&:name).zip(param_types).group_by(&:first)
+            name_to_types.map { |k, v| [k, TypeExpressions::UnionType.new(v.map(&:last))] }.to_h
+          end
         end
 
-        # @param lexical_scope_literals [Array<String>]
-        # @param [Array<Path>]
-        def convert_lexical_scope_literals(lexical_scope_literals)
-          lexical_scope_literals.map { |literal| Path.new(literal) } + [Path.new('Object')]
+        class TypeParser
+          attr_reader :tag
+
+          # @param tag [Store::Objects::Tag]
+          def initialize(tag)
+            @tag = tag
+          end
+
+          # @return [TypeExpressions::Base]
+          def type
+            # yard tag may not have any type literals.
+            if (tag.yard_types || []).empty?
+              TypeExpressions::UnknownType.new('nodoc') 
+            else
+              TypeExpressions.parse_type_strings(tag.yard_types).change_root(convert_lexical_scope_literals(tag.lexical_scope))
+            end
+          end
+
+          # @return [TypeExpressions::Base]
+          def type_of_type_tag
+            Parsing::TypeParser.new.safe_parse(tag.text).change_root(convert_lexical_scope_literals(tag.lexical_scope))
+          end
+
+          private
+
+          # @param lexical_scope_literals [Array<String>]
+          # @param [Array<Path>]
+          def convert_lexical_scope_literals(lexical_scope_literals)
+            lexical_scope_literals.map { |literal| Path.new(literal) } + [Path.new('Object')]
+          end
         end
       end
     end

data/lib/yoda/model/function_signatures/wrapper.rb

@@ -0,0 +1,46 @@
+require 'forwardable'
+
+module Yoda
+  module Model
+    module FunctionSignatures
+      # Wrap {FunctionSignature::Base} and allow it access to environment.
+      # TODO: Merge this with connected store
+      class Wrapper
+        extend Forwardable
+
+        # @return [Environment]
+        attr_reader :environment
+
+        # @return [FunctionSignature::Base]
+        attr_reader :signature
+
+        delegate [:name, :visibility, :sep, :namespace_path, :document, :tags, :sources, :parameters, :primary_source] => :signature
+
+        # @param environment [Environment]
+        # @param signature [FunctionSignature::Base]
+        def initialize(environment:, signature:)
+          @environment = environment
+          @signature = signature
+        end
+
+        # @param env [Environment]
+        # @return [RBS::MethodType]
+        def rbs_type
+          signature.rbs_type(environment)
+        end
+
+        def to_s(include_namespace: false)
+          if include_namespace
+            "#{namespace_path}#{sep}#{name}#{rbs_type.to_s}"
+          else
+            "#{name}#{rbs_type.to_s}"
+          end
+        end
+
+        def wrapper(env)
+          Wrapper.new(environment: env, signature: signature)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/function_signatures.rb

@@ -8,6 +8,8 @@ module Yoda
       require 'yoda/model/function_signatures/parameter_list'
       require 'yoda/model/function_signatures/type_builder'
       require 'yoda/model/function_signatures/formatter'
+      require 'yoda/model/function_signatures/rbs_method'
+      require 'yoda/model/function_signatures/wrapper'
     end
   end
 end

data/lib/yoda/model/lexical_context.rb

@@ -0,0 +1,40 @@
+module Yoda
+  module Model
+    class LexicalContext
+      include Enumerable
+
+      # @return [Array<Path>]
+      attr_reader :paths
+
+      def self.build(paths)
+        new(paths: paths.map { |pa| Path.build(pa) })
+      end
+
+      # @param paths [Array<Path>]
+      def initialize(paths:)
+        @paths = paths
+      end
+
+      # @return [Array<RBS::Namespace>]
+      def to_rbs_context
+        paths.map { |path| Namespace(path.to_s) }
+      end
+
+      def each(&block)
+        paths.each(&block)
+      end
+
+      def ==(another)
+        eql?(another)
+      end
+
+      def eql?(another)
+        another.is_a?(LexicalContext) && paths == another.paths
+      end
+
+      def hash
+        paths.hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Yoda
+  module Model
+    module NodeSignatures
+      # @abstract
+      class Base
+        # @return [Typing::NodeInfo]
+        attr_reader :node_info
+
+        # @param node_info [Typing::NodeInfo]
+        def initialize(node_info)
+          @node_info = node_info
+        end
+
+        # @return [Range]
+        def node_range
+          node_info.range
+        end
+
+        # @abstract
+        # @return [Array<Descriptions::Base>]
+        def descriptions
+          fail NotImplementedError
+        end
+
+        # @return [Array<String, Integer, Integer>]
+        def defined_files
+          []
+        end
+
+        # @return [Descriptions::Base]
+        def node_type_description
+          Descriptions::NodeDescription.new(node_info.node, node_info.type)
+        end
+
+        # @return [Array<Descriptions::Base>]
+        def type_descriptions
+          node_info.objects.map { |object| Descriptions::ValueDescription.new(object) }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/node_signatures/const.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module Model
+    module NodeSignatures
+      class Const < Base
+        def descriptions
+          [node_type_description, *constant_descriptions]
+        end
+
+        def defined_files
+          node_info.constants.map { |value| PrimarySourceInferencer.new.infer_for_object(value) }.compact
+        end
+
+        # @return [Array<Descriptions::Base>]
+        def constant_descriptions
+          node_info.constants.map { |object| Descriptions::ValueDescription.new(object) }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/node_signatures/method_definition.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module Model
+    module NodeSignatures
+      class MethodDefinition < Base
+        def descriptions
+          [node_type_description, *function_descriptions]
+        end
+
+        def function_descriptions
+          node_info.method_candidates.map { |function| Descriptions::FunctionDescription.new(function) }
+        end
+
+        # @return [Array<(String, Integer, Integer)>]
+        def defined_files
+          node_info.method_candidates.map { |function| function.primary_source }.compact
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/node_signatures/node.rb

@@ -0,0 +1,11 @@
+module Yoda
+  module Model
+    module NodeSignatures
+      class Node < Base
+        def descriptions
+          [node_type_description, *type_descriptions]
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/node_signatures/send.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module Model
+    module NodeSignatures
+      class Send < Base
+        def descriptions
+          [node_type_description, *function_descriptions]
+        end
+
+        def function_descriptions
+          node_info.method_candidates.map { |function| Descriptions::FunctionDescription.new(function) }
+        end
+
+        # @return [Array<(String, Integer, Integer)>]
+        def defined_files
+          node_info.method_candidates.map { |function| function.primary_source }.compact
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/node_signatures.rb

@@ -0,0 +1,35 @@
+module Yoda
+  module Model
+    module NodeSignatures
+      require 'yoda/model/node_signatures/base'
+      require 'yoda/model/node_signatures/node'
+      require 'yoda/model/node_signatures/send'
+      require 'yoda/model/node_signatures/method_definition'
+      require 'yoda/model/node_signatures/const'
+
+      class << self
+        # @param node_info [Typing::NodeInfo]
+        # @return [NodeSignatures::Base]
+        def for_node_info(node_info)
+          signature_type_for_node_info(node_info).new(node_info)
+        end
+
+        private
+
+        # @param node_info [Typing::NodeInfo]
+        def signature_type_for_node_info(node_info)
+          case node_info.kind
+          when :def, :defs
+            MethodDefinition
+          when :send
+            Send
+          when :const
+            Const
+          else
+            Node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Yoda
+  module Model
+    module Parameters
+      # @abstract
+      class Base
+        # @abstract
+        # @return [Symbol]
+        def kind
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/parameters/binder.rb

@@ -0,0 +1,148 @@
+module Yoda
+  module Model
+    module Parameters
+      class Binder
+        # @return [Base]
+        attr_reader :parameter
+
+        # @param parameter [Base]
+        def initialize(parameter)
+          @parameter = parameter
+        end
+
+        # @param type [Interface]
+        # @param generator [Generator]
+        # @return [Hash{ Symbol => Interface }]
+        def bind(type:, generator:)
+          BoundResult.new(type: type, parameter: parameter, generator: generator).type_bindings
+        end
+
+        # @abstract
+        module TypeInterface
+        end
+
+        # @abstract
+        module Generator
+          def any_type; fail NotImplementedError; end
+          def proc_type; fail NotImplementedError; end
+          def hash_type; fail NotImplementedError; end
+          def array_type; fail NotImplementedError; end
+        end
+
+        class BoundResult
+          # @return [Interface]
+          attr_reader :type
+
+          # @return [Model::Parameters::Base]
+          attr_reader :parameter
+
+          # @return [Generator]
+          attr_reader :generator
+
+          # @param type [Interface]
+          # @param parameter [Model::Parameters::Multiple] parameter
+          # @param generator [Types::Generator]
+          def initialize(type:, parameter:, generator:)
+            @type = type
+            @parameter = parameter
+            @generator = generator
+          end
+
+          # @return [Hash{Symbol => Interface}]
+          def type_bindings
+            @type_bindings ||= {}
+              .merge!(parameter_bindings)
+              .merge!(keyword_parameter_bindings)
+              .merge!(block_parameter)
+          end
+
+          # @return [Hash{Symbol => Interface}]
+          def parameter_bindings
+            @parameter_bindings ||= begin
+              dict, parameters_remain, types_remain = bind_params_as_possible(parameter.parameters, type.parameters)
+              # TODO: bind with rest paremter type
+              dict = parameters_remain.reduce(dict) { |dict, param| dict.merge(bind_param(param, generator.any_type)) }
+
+              postdict, post_parameters_remain, post_types_remain = bind_params_as_possible(parameter.post_parameters.reverse, type.post_parameters.reverse)
+              dict = dict.merge(postdict)
+              # TODO: bind with rest paremter type
+              dict = post_parameters_remain.reduce(dict) { |dict, param| dict.merge(bind_param(param, generator.any_type)) }
+
+              if parameter.rest_parameter
+                if types_remain.empty? && post_types_remain.empty?
+                  # TODO: bind rest things of keyword and block binding
+                  dict = dict.merge(bind_param(parameter.rest_parameter, type.rest_parameter || generator.array_type))
+                else
+                  # TODO: bind as sequence type
+                  dict = dict.merge(bind_param(parameter.rest_parameter, generator.array_type))
+                end
+              end
+
+              dict
+            end
+          end
+
+          # @return [Hash{Symbol => Interface}]
+          def keyword_parameter_bindings
+            @keyword_parameter_bindings ||= begin
+              type_hash = type.keyword_parameters.to_h
+              dict = parameter.keyword_parameters.reduce({}) do |dict, param|
+                if name = (param.respond_to?(:name) && param.name)
+                  dict.merge(name => type_hash.delete(param) || generator.any_type)
+                else
+                  dict
+                end
+              end
+
+              if parameter.keyword_rest_parameter
+                if type_hash.empty?
+                  dict = dict.merge(bind_param(parameter.keyword_rest_parameter, type.keyword_rest_parameter || generator.hash_type))
+                else
+                  # TODO: merge
+                  dict = dict.merge(bind_param(parameter.keyword_rest_parameter, generator.hash_type))
+                end
+              end
+
+              dict
+            end
+          end
+
+          # @return [Hash{Symbol => Interface}]
+          def block_parameter
+            @block_parameter ||= parameter.block_parameter ? bind_param(parameter.block_parameter, type.block_parameter || generator.proc_type) : {}
+          end
+
+          private
+
+          # @param params [Array<Base>]
+          # @param types [Array<Interface>]
+          # @return [(Hash{Symbol => Interface}, Array<Symbol>, Array<Interface>)]
+          def bind_params_as_possible(params, types)
+            min_length = [params.length, types.length].min
+
+            dict = params.take(min_length).zip(types.take(min_length)).reduce({}) do |memo, (param, type)|
+              memo.merge(bind_param(param, type))
+            end
+
+            [dict, params.drop(min_length), types.drop(min_length)]
+          end
+
+          # @param param [Base]
+          # @param type [Interface]
+          # @return [Hash{Symbol => Interface}]
+          def bind_param(param, type)
+            case param.kind
+            when :named
+              { param.name => type }
+            when :multiple
+              # @todo
+              {}
+            else
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end