yoda-language-server 0.4.0

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

@@ -0,0 +1,82 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      class Formatter
+        # @return [FunctionSignatures::Base]
+        attr_reader :signature
+
+        # @param signature [FunctionSignatures::Base]
+        def initialize(signature)
+          @signature = signature
+        end
+
+        def to_s
+          "#{signature.name}#{function_signature}"
+        end
+
+        private
+
+        def function_signature
+          params = all_parameters
+          (params.empty? ? ': ' : "(#{params.join(', ')}): ") + "#{signature.type.return_type}"
+        end
+
+        def all_parameters
+          [
+            required_parameters,
+            optional_parameters,
+            rest_parameter,
+            post_parameters,
+            required_keyword_parameters,
+            optional_keyword_parameters,
+            keyword_rest_parameter,
+            block_parameter
+          ].flatten.compact
+        end
+
+        def required_parameters
+          signature.parameters.required_parameters.map { |param| triple_to_s(param, type_of(param)) }
+        end
+
+        def optional_parameters
+          signature.parameters.optional_parameters.map { |(param, value)| triple_to_s(param, type_of(param), value) }
+        end
+
+        def post_parameters
+          signature.parameters.post_parameters.map { |param| triple_to_s(param, type_of(param)) }
+        end
+
+        def required_keyword_parameters
+          signature.parameters.required_keyword_parameters.map { |param| "#{type_of(param)} #{param}:" }
+        end
+
+        def optional_keyword_parameters
+          signature.parameters.required_keyword_parameters.map { |(param, value)| "#{type_of(param)} #{param}: #{value}" }
+        end
+
+        def rest_parameter
+          signature.parameters.rest_parameter ? "#{type_of(signature.parameters.rest_parameter)} *#{signature.parameters.rest_parameter}"  : nil
+        end
+
+        def keyword_rest_parameter
+          signature.parameters.keyword_rest_parameter ? "#{type_of(signature.parameters.keyword_rest_parameter)} **#{signature.parameters.keyword_rest_parameter}"  : nil
+        end
+
+        def block_parameter
+          signature.parameters.block_parameter ? "#{type_of(signature.parameters.block_parameter)} **#{signature.parameters.block_parameter}"  : nil
+        end
+
+        # @param name [String]
+        # @param type [Base]
+        # @param default_value [String, nil]
+        def triple_to_s(name, type, default_value = nil)
+          "#{type} #{name}" + (default_value ? " = #{ default_value }" : '')
+        end
+
+        def type_of(param)
+          signature.parameter_type_of(param)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      class Method < Base
+        # @type Store::Objects::MethodObject
+        attr_reader :method_object
+
+        # @param method_object [Store::Objects::MethodObject]
+        def initialize(method_object)
+          fail ArgumentError, method_object unless method_object.is_a?(Store::Objects::MethodObject)
+          @method_object = method_object
+        end
+
+        # @return [String]
+        def name
+          method_object.name.to_s
+        end
+
+        # @return [String]
+        def sep
+          method_object.sep
+        end
+
+        # @return [String]
+        def namespace_path
+          method_object.namespace_path
+        end
+
+        # @return [String]
+        def document
+          @method_object.document
+        end
+
+        # @return [Types::FunctionType]
+        def type
+          type_builder.type
+        end
+
+        # @return [Array<(String, Integer, Integer)>]
+        def sources
+          method_object.source
+        end
+
+        # @return [(String, Integer, Integer), nil]
+        def primary_source
+          method_object.primary_source
+        end
+
+        # @return [ParameterList]
+        def parameters
+          @parameters ||= ParameterList.new(method_object.parameters)
+        end
+
+        def parameter_type_of(param)
+          type_builder.type_of(param)
+        end
+
+        private
+
+        # @return [TypeBuilder]
+        def type_builder
+          @type_builder ||= TypeBuilder.new(parameters, method_object.tag_list)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      class Overload < Base
+        # @return [Store::Objects::MethodObject]
+        attr_reader :method_object
+
+        # @return [Store::Objects::Overload]
+        attr_reader :overload
+
+        # @param method_object [Store::Objects::MethodObject]
+        # @param overload [Store::Objects::Overload]
+        def initialize(method_object, overload)
+          fail ArgumentError, method_object unless method_object.is_a?(Store::Objects::MethodObject)
+          fail ArgumentError, overload unless overload.is_a?(Store::Objects::Overload)
+          @method_object = method_object
+          @overload = overload
+        end
+
+        # @return [Symbol]
+        def visibility
+          method_object.visibility
+        end
+
+        # @return [String]
+        def name
+          method_object.name
+        end
+
+        # @return [String]
+        def sep
+          method_object.sep
+        end
+
+        # @return [String]
+        def document
+          overload.document || method_object.document
+        end
+
+        # @return [Types::FunctionType]
+        def type
+          @type = type_builder.type
+        end
+
+        # @return [Array<(String, Integer, Integer)>]
+        def sources
+          method_object.sources
+        end
+
+        # @abstract
+        # @return [String]
+        def namespace_path
+          method_object.namespace_path
+        end
+
+        # @return [(String, Integer, Integer), nil]
+        def primary_source
+          overload.primary_source || method_object.primary_source
+        end
+
+        # @return [ParameterList]
+        def parameters
+          @parameters ||= ParameterList.new(overload.parameters)
+        end
+
+        def parameter_type_of(param)
+          type_builder.type_of(param)
+        end
+
+        private
+
+        # @return [TypeBuilder]
+        def type_builder
+          @type_builder ||= TypeBuilder.new(parameters, overload.tag_list)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      class ParameterList
+        # @return [Array<(String, String)>]
+        attr_reader :parameters
+
+        # @param parameters [Array<(String, String)>]
+        def initialize(parameters)
+          fail ArgumentError, parameters unless parameters.all? { |param| param.is_a?(Array) }
+          @parameters = parameters
+        end
+
+        # @return [Array<(String, String)>]
+        def to_a
+          parameters
+        end
+
+        # @return [Enumerator<(String, String)>]
+        def each(*args, &proc)
+          to_a.each(*args, &proc)
+        end
+
+        # @return [Array<String>]
+        def parameter_names
+          parameters.map(&:first)
+        end
+
+        # @return [Array<String>]
+        def required_parameters
+          parameter_options[:required_parameters]
+        end
+
+        # @return [Array<String>]
+        def post_parameters
+          parameter_options[:post_parameters]
+        end
+
+        # @return [Array<(String, String)>]
+        def optional_parameters
+          parameter_options[:optional_parameters]
+        end
+
+        # @return [Array<String>]
+        def required_keyword_parameters
+          parameter_options[:required_keyword_parameters]
+        end
+
+        # @return [Array<(String, String)>]
+        def optional_keyword_parameters
+          parameter_options[:optional_keyword_parameters]
+        end
+
+        # @return [String, nil]
+        def rest_parameter
+          parameter_options[:rest_parameter]
+        end
+
+        # @return [String, nil]
+        def keyword_rest_parameter
+          parameter_options[:keyword_rest_parameter]
+        end
+
+        # @return [String, nil]
+        def block_parameter
+          parameter_options[:block_parameter]
+        end
+
+        # @return [Hash{ Symbol => Object }]
+        def parameter_options
+          @parameter_options ||= begin
+            options = {
+              required_parameters: [],
+              optional_parameters: [],
+              rest_parameter: nil,
+              post_parameters: [],
+              required_keyword_parameters: [],
+              optional_keyword_parameters: [],
+              keyword_rest_parameter: nil,
+              block_parameter: nil,
+            }
+            parameters.each_with_object(options) do |(name, default), obj|
+              if name.to_s.start_with?('**')
+                obj[:keyword_rest_parameter] ||= name.to_s.gsub(/\A\*\*/, '')
+              elsif name.to_s.start_with?('*')
+                obj[:rest_parameter] ||= name.to_s.gsub(/\A\*/, '')
+              elsif name.to_s.start_with?('&')
+                obj[:block_parameter] ||= name.to_s.gsub(/\A\&/, '')
+              elsif name.to_s.end_with?(':')
+                if default && !default.empty?
+                  obj[:optional_keyword_parameters].push([name.to_s.gsub(/:\Z/, ''), default])
+                else
+                  obj[:required_keyword_parameters].push(name.to_s.gsub(/:\Z/, ''))
+                end
+              elsif default && !default.empty?
+                obj[:optional_parameters].push([name, default])
+              elsif obj[:rest_parameter]
+                obj[:post_parameters].push(name.to_s)
+              else
+                obj[:required_parameters].push(name.to_s)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module Yoda
+  module Model
+    module FunctionSignatures
+      class TypeBuilder
+        # @return [ParameterList]
+        attr_reader :parameters
+
+        # @return [Array<Store::Objects::Tag>]
+        attr_reader :tag_list
+
+        # @param parameters [ParameterList]
+        # @param tag_list [Array<Store::Objects::Tag>]
+        # @param lexical_scope [Array<Store::Objects::Tag>]
+        def initialize(parameters, tag_list)
+          @parameters = parameters
+          @tag_list = tag_list
+        end
+
+        # @return [Types::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)
+            else
+              Types::FunctionType.new(return_type: return_types.first || Types::UnknownType.new('nodoc'), **parameter_options)
+            end
+          end
+        end
+
+        # @param param [String]
+        # @return [Types::Base]
+        def type_of(param)
+          param_type_table[param] || Types::UnknownType.new('nodoc')
+        end
+
+        private
+
+        # @param type_tag [Store::Objects::Tag]
+        # @return [Types::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)
+        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,
+          }
+        end
+
+        # @return [Array<Store::Objects::Tag>]
+        def return_tags
+          @return_tag ||= tag_list.select { |tag| tag.tag_name == 'return' }
+        end
+
+        # @return [Array<Store::Objects::Tag>]
+        def type_tags
+          @type_tag ||= tag_list.select { |tag| tag.tag_name == 'type' }
+        end
+
+        # @return [Array<Store::Objects::Tag>]
+        def param_tags
+          @param_tags ||= tag_list.select { |tag| tag.tag_name == 'param' }
+        end
+
+        # @return [Array<Types::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))
+          end
+        end
+
+        # @return [{ String => Types::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
+        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')]
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/node_signature.rb

@@ -0,0 +1,28 @@
+module Yoda
+  module Model
+    class NodeSignature
+      attr_reader :node, :trace
+      # @param node  [::Parser::AST::Node]
+      # @param trace [Typing::Traces::Base]
+      def initialize(node, trace)
+        @node = node
+        @trace = trace
+      end
+
+      # @return [Range]
+      def node_range
+        Parsing::Range.of_ast_location(node.location)
+      end
+
+      # @return [Array<Descriptions::Base>]
+      def descriptions
+        case trace
+        when Typing::Traces::Send
+          trace.functions.map { |function| Descriptions::FunctionDescription.new(function) }.take(1)
+        else
+          trace.values.map { |value| Descriptions::ValueDescription.new(value) }
+        end
+      end
+    end
+  end
+end