yoda-language-server 0.7.2 → 0.10.0

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,13 @@ 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/require_path_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

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

@@ -0,0 +1,66 @@
+require 'forwardable'
+
+require 'yoda/model/environment/accessor_interface'
+require 'yoda/model/environment/with_cache'
+
+module Yoda
+  module Model
+    class Environment
+      class SingletonAccessor
+        extend Forwardable
+        include AccessorInterface
+        include WithCache
+
+        # @return [InstanceAccessor, SingletonAccessor]
+        attr_reader :instance_accessor
+
+        delegate [:rbs_definition_builder, :environment] => :instance_accessor
+
+        # @param instance_accessor [InstanceAccessor, SingletonAccessor]
+        def initialize(instance_accessor)
+          @instance_accessor = instance_accessor
+        end
+
+        # @return [NamespaceMembers]
+        def members
+          @members ||= NamespaceMembers.new(accessor: self, environment: environment)
+        end
+
+        # @return [SingletonAccessor]
+        def singleton_accessor
+          SingletonAccessor.new(self)
+        end
+
+        # @return [RBS::Definition, nil]
+        def rbs_definition
+          with_cache(:rbs_definition) do
+            if instance_accessor.rbs_definition
+              if instance_accessor.rbs_definition.self_type.is_a?(RBS::Types::ClassInstance)
+                rbs_definition_builder.build_singleton(instance_accessor.rbs_definition.type_name)
+              else
+                # Interface or Singleton
+                nil
+              end
+            else
+              nil
+            end
+          end
+        end
+
+        # @return [Store::Objects::MetaClassObject::Connected, nil]
+        def class_object
+          with_cache(:class_object) do
+            instance_accessor.class_object&.meta_class
+          end
+        end
+
+        # @return [Store::Objects::MetaClassObject::Connected, nil]
+        def self_object
+          with_cache(:self_object) do
+            instance_accessor.class_object
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+require 'rbs'
+
+module Yoda
+  module Model
+    class Environment
+      # Environment can instanciate {Values::Base} objects from rbs types
+      class ValueFactory
+        # @return [Environment]
+        attr_reader :environment
+
+        # @param project [Store::Project]
+        def self.from_environment(environment)
+          new(environment: environment)
+        end
+
+        # @param environment [Environment]
+        def initialize(environment:)
+          @environment = environment
+        end
+
+        # @param type [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, ValueResolveContext::WrappedType]
+        # @return [Values::Base, nil]
+        def resolve_value_by_rbs_type(type, context: ValueResolveContext.empty)
+          return resolve_value_by_rbs_type(type.wrapped_type, context: type.context) if type.respond_to?(:act_as_type_wrapper?)
+
+          case type
+          when RBS::Types::Bases::Any
+            Values::EmptyValue.new
+          when RBS::Types::Bases::Top
+            # TODO: Implement as everything.
+            Values::EmptyValue.new
+          when RBS::Types::Bases::Bottom
+            Values::EmptyValue.new
+          when RBS::Types::Bases::Void
+            Values::EmptyValue.new
+          when RBS::Types::Bases::Bool
+            Values::UnionValue.new(
+              resolve_instance_by_rbs_type_name(TypeName("::TrueClass")),
+              resolve_instance_by_rbs_type_name(TypeName("::FalseClass")),
+            )
+          when RBS::Types::Bases::Nil
+            resolve_instance_by_rbs_type_name(TypeName("::NilClass"))
+          when RBS::Types::ClassSingleton
+            resolve_singleton_by_rbs_type_name(type.name)
+          when RBS::Types::ClassInstance
+            resolve_instance_by_rbs_type_name(type.name, args: type.args)
+          when RBS::Types::Interface
+            args = type.args.map {|arg| resolve_value_by_rbs_type(arg, context: context) }
+
+            resolve_interface_by_rbs_type_name(type.name, args: type.args)
+          when RBS::Types::Union
+            Values::UnionValue.new(
+              *type.types.flat_map { |ty| resolve_value_by_rbs_type(ty, context: context) }
+            )
+          when RBS::Types::Optional
+            Values::UnionValue.new(
+              resolve_value_by_rbs_type(type.type),
+              resolve_instance_by_rbs_type_name(TypeName("::NilClass")),
+            )
+          when RBS::Types::Intersection
+            Values::IntersectionValue.new(
+              *type.types.map { |ty| resolve_value_by_rbs_type(ty, context: context) }
+            )
+          when RBS::Types::Literal
+            literal_instance(type.literal)
+          when RBS::Types::Tuple
+            # TODO: Implement as tuple
+            # Values::Tuple.new(value_lists: type.types.map { |ty| resolve_value_by_rbs_type(ty) })
+
+            resolve_instance_by_rbs_type_name(TypeName("::Array"))
+          when RBS::Types::Record
+            # TODO: Implement as record
+            # Values::Tuple.new(values_map: type.fields.map { |(key, value)| [key, resolve_value_by_rbs_type(value)] }.to_h)
+            resolve_instance_by_rbs_type_name(TypeName("::Hash"))
+          when RBS::Types::Proc
+            # TODO: Implement as proc
+            # Values::Proc.new("::Proc", type_args: type)
+            resolve_instance_by_rbs_type_name(TypeName("::Proc"))
+          when RBS::Types::Alias
+            rbs_alias = environment.rbs_environment.alias_decls[type.name]&.decl
+
+            if rbs_alias
+              resolve_value_by_rbs_type(rbs_alias.type)
+            else
+              Values::EmptyValue.new
+            end
+          when RBS::Types::Variable
+            Logger.warn("Value factory does not has proper information to convert #{type}.")
+            Values::EmptyValue.new
+          when RBS::Types::Bases::Self
+            if context.self_type
+              resolve_value_by_rbs_type(context.self_type)
+            else
+              Logger.warn("Value factory does not has proper information to convert #{type}.")
+              Values::EmptyValue.new
+            end
+          when RBS::Types::Bases::Class
+            if context.self_type
+              resolve_value_by_rbs_type(context.self_type).singleton_class_value
+            else
+              Logger.warn("Value factory does not has proper information to convert #{type}.")
+              Values::EmptyValue.new
+            end
+          when RBS::Types::Bases::Instance
+            if context.self_type
+              resolve_value_by_rbs_type(context.self_type).instance_value
+            else
+              Logger.warn("Value factory does not has proper information to convert #{type}.")
+              Values::EmptyValue.new
+            end
+          else
+            raise "Unexpected type given: #{type}"
+          end
+        end
+
+        private
+
+        # @param rbs_type_name [RBS::TypeName]
+        # @param args [Array<RBS::Types::t]
+        # @return [Values::InstanceValue]
+        def resolve_instance_by_rbs_type_name(rbs_type_name, args: [])
+          accessor = InstanceAccessor.new(environment: environment, path: rbs_type_name.to_s, type_args: args)
+          Values::InstanceValue.new(accessor)
+        end
+
+        # @param rbs_type_name [RBS::TypeName]
+        # @param args [RBS::Types::t]
+        # @return [Values::InstanceValue]
+        def resolve_singleton_by_rbs_type_name(rbs_type_name, args: [])
+          accessor = InstanceAccessor.new(environment: environment, path: rbs_type_name.to_s, type_args: args).singleton_accessor
+          Values::InstanceValue.new(accessor)
+        end
+
+        # @param rbs_type_name [RBS::TypeName]
+        # @param args [RBS::Types::t]
+        # @return [Valuess::InstanceValue]
+        def resolve_interface_by_rbs_type_name(rbs_type_name, args: [])
+          accessor = InstanceAccessor.new(environment: environment, path: rbs_type_name.to_s, type_args: args)
+          Values::InstanceValue.new(accessor)
+        end
+
+        def literal_instance(literal)
+          type_name = TypeName(literal.class.name)
+          value = resolve_instance_by_rbs_type_name(type_name)
+
+          Values::LiteralValue.new(value: value, literal: literal)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'delegate'
+
+module Yoda
+  module Model
+    class Environment
+      class ValueResolveContext
+        # @return [ValueResolveContext]
+        def self.empty
+          new
+        end
+
+        # @return [RBS::Types::t, nil]
+        attr_reader :self_type
+
+        # @param self_type [RBS::Types::t, nil]
+        def initialize(self_type: nil)
+          @self_type = self_type
+        end
+
+        # @param type [RBS::Types::t]
+        def wrap(type)
+          WrappedType.new(type, context: self)
+        end
+
+        class WrappedType < SimpleDelegator
+          # @return [ValueResolveContext]
+          attr_reader :context
+
+          # @param type [RBS::Types::t]
+          # @param context [ValueResolveContext]
+          def initialize(type, context:)
+            @context = context
+            super(type)
+          end
+
+          def act_as_type_wrapper?
+            wrapped_type
+          end
+
+          # @return [WrappedType]
+          def propage_context_to(another_type)
+            context.wrap(another_type)
+          end
+
+          # @param type [RBS::Types::t]
+          def wrapped_type
+            __getobj__
+          end
+
+          # @param pp [PP]
+          def pretty_print(pp)
+            pp.object_group(self) do
+              pp.breakable
+              pp.text "type:"
+              pp.pp wrapped_type
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Yoda
+  module Model
+    class Environment
+      module WithCache
+        # @param with_cache [Symbol]
+        def with_cache(cache_name)
+          cache_key = :"@#{cache_name}"
+          return instance_variable_get(cache_key) if instance_variable_defined?(cache_key)
+          instance_variable_set(cache_key, yield)
+        end
+      end
+    end
+  end
+end