yoda-language-server 0.7.2 → 0.10.0

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,19 @@
+module Yoda
+  module Model
+    module NodeSignatures
+      class Node < Base
+        def descriptions
+          if node_info.require_paths.empty?
+            [node_type_description, *type_descriptions]
+          else
+            node_info.require_paths.map { |path| Descriptions::RequirePathDescription.new(path) }
+          end
+        end
+
+        def defined_files
+          node_info.require_paths.map { |path| [path, Parsing::Location.first_row, Parsing::Location.first_column] }
+        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

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

@@ -0,0 +1,36 @@
+module Yoda
+  module Model
+    module Parameters
+      class Multiple < Base
+        # @return [Array<Base>]
+        attr_reader :parameters, :post_parameters
+
+        # @return [Array<Base>]
+        attr_reader :keyword_parameters
+
+        # @return [Base, nil]
+        attr_reader :rest_parameter, :keyword_rest_parameter, :block_parameter
+
+        # @param parameters [Array<Base>]
+        # @param rest_parameter [Base, nil]
+        # @param post_parameters [Array<Base>]
+        # @param keyword_parameters [Array<(Base)>]
+        # @param keyword_rest_parameter [Base, nil]
+        # @param block_parameter [Base, nil]
+        def initialize(parameters: [], rest_parameter: nil, post_parameters: [], keyword_parameters: [], keyword_rest_parameter: nil, block_parameter: nil)
+          @parameters = parameters
+          @keyword_parameters = keyword_parameters
+          @rest_parameter = rest_parameter
+          @post_parameters = post_parameters
+          @keyword_rest_parameter = keyword_rest_parameter
+          @block_parameter = block_parameter
+        end
+
+        # @return [Symbol]
+        def kind
+          :multiple
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Yoda
+  module Model
+    module Parameters
+      class Named < Base
+        # @return [Symbol]
+        attr_reader :name
+
+        # @param name [String, Symbol]
+        def initialize(name)
+          @name = name.to_sym
+        end
+
+        # @return [Symbol]
+        def kind
+          :named
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Model
+    module Parameters
+      class Unnamed < Base
+        # @return [Symbol]
+        def kind
+          :unnamed
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/parameters.rb

@@ -0,0 +1,11 @@
+module Yoda
+  module Model
+    module Parameters
+      require 'yoda/model/parameters/base'
+      require 'yoda/model/parameters/multiple'
+      require 'yoda/model/parameters/named'
+      require 'yoda/model/parameters/unnamed'
+      require 'yoda/model/parameters/binder'
+    end
+  end
+end

data/lib/yoda/model/path.rb

@@ -21,10 +21,16 @@ module Yoda
         @name = name
       end
 
+      # @return [Boolean]
       def absolute?
         name.start_with?('::')
       end
 
+      # @return [Path]
+      def absolute!
+        absolute? ? self : Path.new("::#{to_s}")
+      end
+
       # @return [String]
       def basename
         @basename ||= begin
@@ -71,6 +77,16 @@ module Yoda
         name.split('::')
       end
 
+      # @return [Array<Path>]
+      def absolute_paths
+        [self.absolute!]
+      end
+
+      # @return [Array<Path>]
+      def paths
+        [self]
+      end
+
       # @return [Array<Path>]
       def parent_paths
         if spacename.empty?

data/lib/yoda/model/primary_source_inferencer.rb

@@ -0,0 +1,34 @@
+module Yoda
+  module Model
+    class PrimarySourceInferencer
+      def initialize
+      end
+
+      # @param object [Yoda::Store::Objects::Base]
+      def infer_for_object(object)
+        object.primary_source || infer_primary_source_from_object_sources(object)
+      end
+
+      private
+
+      # @param object [Yoda::Store::Objects::Base]
+      def infer_primary_source_from_object_sources(object)
+        source_with_object_name =
+          object.sources.find do |(source_file, _row, _column)|
+            basename = File.basename(source_file, ".*")
+            object.name == to_constant_name(basename)
+          end
+
+        return source_with_object_name if source_with_object_name
+
+        object.sources.first
+      end
+
+      def to_constant_name(str)
+        str = str.to_s.split("/").last
+        # camelize
+        str.sub(/^[a-z]*/) { |match| match.capitalize }.gsub(/(?:_)([a-z]*)/i) { $1.capitalize }
+      end
+    end
+  end
+end

data/lib/yoda/model/scoped_path.rb

@@ -3,8 +3,9 @@ module Yoda
     # ScopedPath represents a path name written in namespaces.
     # ScopedPath owns lexical scopes where the path is written.
     class ScopedPath
-      # @return [Array<Path>] represents namespaces in order of nearness.
+      # @return [LexicalContext] represents namespaces in order of nearness.
       attr_reader :scopes
+      alias lexical_context scopes
 
       # @return [Path]
       attr_reader :path
@@ -18,7 +19,7 @@ module Yoda
       # @param scopes [Array<Path>] represents namespaces in order of nearness.
       # @param path [Path]
       def initialize(scopes, path)
-        @scopes = scopes.map { |pa| Path.build(pa) }
+        @scopes = LexicalContext.build(scopes)
         @path = Path.build(path)
       end
 
@@ -39,6 +40,16 @@ module Yoda
       def eql?(another)
         another.is_a?(ScopedPath) && path == another.path && scopes == another.scopes
       end
+
+      # @return [Array<Path>]
+      def absolute_paths
+        scopes.map { |scope| Path.from_names([scope, path]).absolute! }
+      end
+
+      # @return [Array<Path>]
+      def paths
+        scopes.map { |scope| Path.from_names([scope, path]) }
+      end
     end
   end
 end

data/lib/yoda/model/{types → type_expressions}/any_type.rb

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class AnyType < Base
         def eql?(another)
           another.is_a?(AnyType)
@@ -10,7 +10,7 @@ module Yoda
           [self.class.name].hash
         end
 
-        # @param paths [Array<Paths>]
+        # @param paths [LexicalContext]
         # @return [self]
         def change_root(paths)
           self
@@ -22,9 +22,13 @@ module Yoda
           []
         end
 
+        def to_rbs_type(_env)
+          RBS::Types::Bases::Any.new(location: nil)
+        end
+
         # @return [String]
         def to_s
-          'any'
+          'untyped'
         end
       end
     end

data/lib/yoda/model/{types → type_expressions}/base.rb

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       # @abstract
       class Base
         def ==(another)
@@ -8,9 +8,9 @@ module Yoda
         end
 
         # @abstract
-        # @param paths [Array<Path>]
+        # @param new_lexical_context [LexicalContext]
         # @return [Base]
-        def change_root(paths)
+        def change_root(new_lexical_context)
           fail NotImplementedError
         end
 
@@ -27,6 +27,13 @@ module Yoda
           fail NotImplementedError
         end
 
+        # @abstract
+        # @param env [Environment]
+        # @return [RBS::Types::Bases::Base, RBS::Types::Variable, RBS::Types::ClassSingleton, RBS::Types::Interface, RBS::Types::ClassInstance, RBS::Types::Alias, RBS::Types::Tuple, RBS::Types::Record, RBS::Types::Optional, RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Function, RBS::Types::Block, RBS::Types::Proc, RBS::Types::Literal]
+        def to_rbs_type(env)
+          fail NotImplementedError
+        end
+
         # @return [Base]
         def map
           yield self

data/lib/yoda/model/{types → type_expressions}/duck_type.rb

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class DuckType < Base
         attr_reader :method_name
 
@@ -19,7 +19,7 @@ module Yoda
           [self.class.name, method_name].hash
         end
 
-        # @param paths [Array<Paths>]
+        # @param paths [LexicalContext]
         # @return [self]
         def change_root(paths)
           self
@@ -31,6 +31,12 @@ module Yoda
           []
         end
 
+        # @param env [Environment]
+        def to_rbs_type(env)
+          # TODO: Implement as interface type
+          RBS::Types::Bases::Any.new(location: nil)
+        end
+
         # @return [String]
         def to_s
           "##{method_name}"

data/lib/yoda/model/type_expressions/function_type/parameter.rb

@@ -0,0 +1,95 @@
+module Yoda
+  module Model
+    module TypeExpressions
+      class FunctionType
+        class Parameter
+          # @return [String, nil]
+          attr_reader :name
+
+          # @return [Base]
+          attr_reader :type
+
+          # @param name [String, nil]
+          # @param type [Base]
+          def initialize(name: nil, type:)
+            @name = name
+            @type = type
+          end
+
+          # @param env [Environment]
+          # @return [RBS::Types::Function::Param]
+          def to_rbs_param(env)
+            RBS::Types::Function::Param.new(type: type.to_rbs_type(env), name: name.to_sym)
+          end
+
+          def map_type(&block)
+            self.class.new(name: name, type: block.call(type))
+          end
+
+          def ==(another)
+            eql?(another)
+          end
+
+          def eql?(another)
+            another.is_a?(Parameter) && name == another.name && type == another.type
+          end
+
+          def hash
+            [self.class.name, name, type].hash
+          end
+
+          # @return [String]
+          def keyword_expression(optional: false)
+            prefix = optional ? "?" : ""
+            "#{prefix}#{name}: #{type}"
+          end
+
+          # @return [String]
+          def optional_keyword_expression
+            keyword_expression(optional: true)
+          end
+
+          # @return [String]
+          def keyword_rest_expression
+            "**#{type} #{name}"
+          end
+
+          # @return [String]
+          def optional_expression
+            positional_expression(optional: true)
+          end
+
+          # @return [String]
+          def rest_expression
+            positional_expression(rest: true)
+          end
+
+          # @return [String]
+          def block_expression
+            positional_expression(block: true)
+          end
+
+          # @return [String]
+          def positional_expression(optioanl: false, rest: false, block: false)
+            prefix = begin
+              if optional
+                "?" 
+              elsif rest
+                "*"
+              elsif block
+                "&"
+              else
+                ""
+              end
+            end
+            if name
+              "#{prefix}#{type} #{name}"
+            else
+              "#{prefix}#{type}"
+            end
+          end
+        end
+      end
+    end
+  end
+end