yoda-language-server 0.7.2 → 0.10.0

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

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