yoda-language-server 0.7.0 → 0.8.0

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

data/lib/yoda/model/environment.rb

@@ -0,0 +1,122 @@
+require 'rbs'
+
+module Yoda
+  module Model
+    # Environment can resolve constants from type expressions.
+    class Environment
+      require 'yoda/model/environment/accessor_interface'
+      require 'yoda/model/environment/instance_accessor'
+      require 'yoda/model/environment/namespace_members'
+      require 'yoda/model/environment/singleton_accessor'
+      require 'yoda/model/environment/value_factory'
+      require 'yoda/model/environment/value_resolve_context'
+      require 'yoda/model/environment/with_cache'
+
+
+      # @param project [Store::Project]
+      def self.from_project(project)
+        new(registry: project.registry, rbs_environment: project.rbs_environment)
+      end
+
+      # @param registry [Store::Registry::ProjectRegistry, nil]
+      # @param rbs_environment [RBS::Environment, nil]
+      # @return [Environment]
+      def self.build(registry: nil, rbs_environment: nil)
+        # TODO: Allow to make registry parameter empty
+        registry ||= Yoda::Store::Project.temporal.registry
+        rbs_environment ||= RBS::Environment.new
+        new(registry: registry, rbs_environment: rbs_environment)
+      end
+
+      # @return [Store::Registry::ProjectRegistry]
+      attr_reader :registry
+
+      # @return [RBS::Environment]
+      attr_reader :rbs_environment
+
+      # @param registry [Store::Registry::ProjectRegistry]
+      # @param rbs_environment [RBS::Environment]
+      def initialize(registry:, rbs_environment:)
+        @registry = registry
+        @rbs_environment = rbs_environment
+      end
+
+      # @param rbs_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]
+      # @return [Values::Base, nil]
+      def resolve_value_by_rbs_type(rbs_type)
+        ValueFactory.from_environment(self).resolve_value_by_rbs_type(rbs_type)
+      end
+
+      # @param type_expression [TypeExpression]
+      # @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 resolve_rbs_type(type_expression)
+        type_expression.to_rbs_type(self)
+      end
+
+      # Return {RBS::TypeName} for the instance of the given path.
+      # @param path [ScopedPath, Path, String]
+      # @return [RBS::TypeName, nil]
+      def resolve_rbs_type_name(path)
+        scoped_path = ScopedPath.build(path)
+        # TODO: ask both registry in lexical priority
+        object = resolve_constant(scoped_path)
+        return TypeName(object.path).absolute! if object
+        rbs_type_name_resolver.resolve(TypeName(scoped_path.path.to_s), context: scoped_path.lexical_context.to_rbs_context)
+      end
+
+      # @param key [String, Path, ScopedPath]
+      # @return [Store::Objects::Base, nil]
+      def resolve_constant(key)
+        Store::Query::FindConstant.new(registry).find(key)&.with_connection(registry: registry)
+      end
+
+      # @param key [String, Path, ScopedPath]
+      # @return [Store::Objects::MetaClassObject, nil]
+      def resolve_singleton_class(key)
+        Store::Query::FindMetaClass.new(registry).find(key)&.with_connection(registry: registry)
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param return [RBS::AST::Declarations::Class, nil]
+      def resolve_rbs_class_decl(type_name)
+        rbs_environment.class_decls[type_name]
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param return [RBS::AST::Declarations::Interface, nil]
+      def resolve_rbs_interface_decl(type_name)
+        rbs_environment.interface_decls[type_name]&.decl
+      end
+
+      # @param type_name [RBS::TypeName]
+      # @param return [RBS::AST::Declarations::Constant, nil]
+      def resolve_rbs_constant_decl(type_name)
+        environment.rbs_environment.constant_decls[type_name]&.decl
+      end
+
+      # @param pp [PP]
+      def pretty_print(pp)
+        pp.object_group(self) do
+          pp.breakable
+          pp.text "@rbs_environment="
+          pp.pp rbs_environment
+          pp.comma_breakable
+          pp.text "@registry="
+          pp.pp registry
+        end
+      end
+
+      private
+
+      # @param scoped_path [ScopedPath]
+      def resolve_rbs_decl(scoped_path)
+        type_name = resolve_type_name(scoped_path)
+      end
+
+      def rbs_type_name_resolver
+        @rbs_type_name_resolver ||= RBS::TypeNameResolver.from_env(rbs_environment)
+      end
+
+    end
+  end
+end

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

@@ -4,11 +4,18 @@ module Yoda
       # @abstract
       class Base
         # @abstract
-        # @return [Types::FunctionType]
+        # @return [TypeExpressions::FunctionType]
         def type
           fail NotImplementedError
         end
 
+        # @abstract
+        # @param env [Environment]
+        # @return [RBS::MethodType]
+        def rbs_type(env)
+          fail NotImplementedError
+        end
+
         # @abstract
         # @return [Symbol]
         def visibility
@@ -33,6 +40,12 @@ module Yoda
           fail NotImplementedError
         end
 
+        # @abstract
+        # @return [Array<Store::Objects::Tag>]
+        def tags
+          fail NotImplementedError
+        end
+
         # @abstract
         # @return [ParameterList]
         def parameters
@@ -51,11 +64,18 @@ module Yoda
         end
 
         # @abstract
-        # @return [Types::Base, nil]
+        # @param param [String]
+        # @return [TypeExpressions::Base, nil]
         def parameter_type_of(param)
           fail NotImplementedError
         end
 
+        # @param env [Environment]
+        # @return [Wrapper]
+        def wrap(env)
+          Wrapper.new(environment: env, signature: self)
+        end
+
         private
 
         # @return [Formatter]

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

@@ -17,6 +17,17 @@ module Yoda
           type_builder.type
         end
 
+        # @param env [Environment]
+        # @return [RBS::MethodType]
+        def rbs_type(env)
+          RBS::MethodType.new(
+            type_params: [],
+            type: type.to_rbs_type(env),
+            block: nil,
+            location: nil,
+          )
+        end
+
         def name
           'new'
         end
@@ -38,6 +49,11 @@ module Yoda
           initialize_method.document
         end
 
+        # @return [Array<Store::Objects::Tag>]
+        def tags
+          initialize_method.tag_list
+        end
+
         # @return [Array<(String, Integer, Integer)>]
         def sources
           initialize_method.sources
@@ -53,7 +69,7 @@ module Yoda
           initialize_method.primary_source
         end
 
-        # @return [Types::Base, nil]
+        # @return [TypeExpressions::Base, nil]
         def parameter_type_of(param)
           type_builder.type_of(param)
         end

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

@@ -2,7 +2,7 @@ module Yoda
   module Model
     module FunctionSignatures
       class Method < Base
-        # @type Store::Objects::MethodObject
+        # @return [Store::Objects::MethodObject]
         attr_reader :method_object
 
         # @param method_object [Store::Objects::MethodObject]
@@ -31,11 +31,27 @@ module Yoda
           @method_object.document
         end
 
-        # @return [Types::FunctionType]
+        # @return [Array<Store::Objects::Tag>]
+        def tags
+          method_object.tag_list
+        end
+
+        # @return [TypeExpressions::FunctionType]
         def type
           type_builder.type
         end
 
+        # @param env [Environment]
+        # @return [RBS::MethodType]
+        def rbs_type(env)
+          RBS::MethodType.new(
+            type_params: [],
+            type: type.to_rbs_type(env),
+            block: nil,
+            location: nil,
+          )
+        end
+
         # @return [Array<(String, Integer, Integer)>]
         def sources
           method_object.source

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

@@ -37,11 +37,27 @@ module Yoda
           overload.document || method_object.document
         end
 
-        # @return [Types::FunctionType]
+        # @return [Array<Store::Objects::Tag>]
+        def tags
+          overload.tag_list || method_object.tag_list
+        end
+
+        # @return [TypeExpressions::FunctionType]
         def type
           @type = type_builder.type
         end
 
+        # @param env [Environment]
+        # @return [RBS::MethodType]
+        def rbs_type(env)
+          RBS::MethodType.new(
+            type_params: [],
+            type: type.to_rbs_type(env),
+            block: nil,
+            location: nil,
+          )
+        end
+
         # @return [Array<(String, Integer, Integer)>]
         def sources
           method_object.sources

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