yoda-language-server 0.7.2 → 0.10.0

data/lib/yoda/typing/contexts/base_context.rb

@@ -0,0 +1,83 @@
+require 'forwardable'
+require 'yoda/typing/contexts/context_derivation'
+
+module Yoda
+  module Typing
+    module Contexts
+      # @abstract
+      class BaseContext
+        extend Forwardable
+        include ContextDerivation
+
+        # @return [Model::Environment]
+        attr_reader :environment
+
+        # @return [Types::Type]
+        attr_reader :receiver
+
+        # @return [Types::Type]
+        attr_reader :constant_ref
+
+        # @return [BaseContext, nil]
+        attr_reader :parent
+
+        # @return [Inferencer::TypeBinding]
+        attr_reader :type_binding
+
+        delegate [:resolve_value_by_rbs_type]
+
+        # @param environment   [Model::Environment]
+        # @param receiver      [Types::Type] represents who is self of the code.
+        # @param constant_ref  [Types::Type] represents who is self of the code.
+        # @param parent        [BaseContext, nil]
+        # @param binds         [Hash{Symbol => RBS::Types::t}, nil]
+        def initialize(environment:, receiver:, constant_ref:, parent: nil, binds: nil)
+          @environment = environment
+          @receiver = receiver
+          @constant_ref = constant_ref
+          @parent = parent
+          @type_binding = Inferencer::TypeBinding.new(parent: parent_variable_scope_context&.type_binding, binds: binds)
+        end
+
+        # @deprecated Use methods of {BaseContext} instead.
+        def registry
+          environment.registry
+        end
+
+        def method_receiver
+          constant_ref.instance_type
+        end
+
+        # @abstract
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          fail NotImplementedError
+        end
+
+        # @return [Array<Types::Type>]
+        def lexical_scope_types
+          @lexical_scope_types ||= begin
+            parent_types = parent&.lexical_scope_types || []
+            if parent.nil?
+              [constant_ref]
+            elsif parent && constant_ref != parent.constant_ref
+              parent_types + [constant_ref]
+            else
+              parent_types
+            end
+          end
+        end
+
+        # @return [Types::Generator]
+        def generator
+          Types::Generator.new(environment: environment)
+        end
+
+        # @return [ConstantResolver]
+        def constant_resolver
+          ConstantResolver.new(context: self)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/block_context.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      class BlockContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          parent
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/context_derivation.rb

@@ -0,0 +1,59 @@
+module Yoda
+  module Typing
+    module Contexts
+      module ContextDerivation
+        # @abstract
+        # @return [Model::Environment]
+        def environment
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Types::Type]
+        def receiver
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Types::Type]
+        def constant_ref
+          fail NotImplementedError
+        end
+
+        # @param class_type [Types::Type]
+        def derive_class_context(class_type:)
+          NamespaceContext.new(
+            parent: self,
+            environment: environment,
+            receiver: class_type,
+            constant_ref: class_type,
+          )
+        end
+
+        # @param receiver_type [Types::Type]
+        # @param binds         [Hash{Symbol => Types::Type}, nil]
+        def derive_method_context(receiver_type:, binds:)
+          MethodContext.new(
+            parent: self,
+            environment: environment,
+            receiver: receiver_type,
+            constant_ref: constant_ref,
+            binds: binds,
+          )
+        end
+
+        # @param receiver_type [Types::Type]
+        # @param binds         [Hash{Symbol => Types::Type}, nil]
+        def derive_block_context(binds:, receiver_type: nil)
+          BlockContext.new(
+            parent: self,
+            environment: environment,
+            receiver: receiver_type || receiver,
+            constant_ref: constant_ref,
+            binds: binds,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/method_context.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      class MethodContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/namespace_block_context.rb

@@ -0,0 +1,29 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      # Block context which has its lexical scope (for instance_eval and instance_exec)
+      class NamespaceBlockContext < BaseContext
+        # @return [Store::Objects::NamespaceObject]
+        attr_reader :objects
+
+        # @param namespaces [Array<Store::Objects::NamespaceObject>] namespace objects which context resolution and method definition refer
+        def initialize(objects:, **kwargs)
+          @objects = objects
+          super(**kwargs)
+        end
+
+        # @return [Array<Store::Objects::NamespaceObject>]
+        def current_objects
+          objects
+        end
+
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          parent
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/namespace_context.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      class NamespaceContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts.rb

@@ -0,0 +1,25 @@
+module Yoda
+  module Typing
+    module Contexts
+      require 'yoda/typing/contexts/base_context'
+      require 'yoda/typing/contexts/block_context'
+      require 'yoda/typing/contexts/method_context'
+      require 'yoda/typing/contexts/namespace_block_context'
+      require 'yoda/typing/contexts/namespace_context'
+
+      # @return [NamespaceContext]
+      def self.root_scope(environment:)
+        generator = Types::Generator.new(environment: environment)
+
+        object_type = generator.instance_type_at("::Object")
+        object_class_type = generator.singleton_type_at("::Object")
+
+        NamespaceContext.new(
+          environment: environment,
+          receiver: object_type,
+          constant_ref: object_class_type,
+        )
+      end
+    end
+  end
+end

data/lib/yoda/typing/environment.rb

@@ -13,7 +13,7 @@ module Yoda
       end
 
       # @param key  [String, Symbol]
-      # @param type [Symbol, Model::Types::Base]
+      # @param type [Symbol, Model::TypeExpressions::Base]
       def bind(key, type)
         key = key.to_sym
         type = (type.is_a?(Symbol) && resolve(type)) || type

data/lib/yoda/typing/inferencer/arguments.rb

@@ -0,0 +1,38 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class Arguments
+        # @param argument_nodes [Array<AST::Node>]
+        # @param tracer [Tracer]
+        def initialize(argument_nodes, tracer)
+          @argument_nodes = argument_nodes
+          @tracer = tracer
+        end
+
+        # @param signature [Model::FunctionSignatures::Base]
+        # @return [Boolean]
+        def accepted_by?(signature)
+          signature.parameters
+        end
+
+        # @param nodes [Array<::AST::Node>]
+        # @return [{Symbol => Types::Base}]
+        def infer_argument_nodes(argument_nodes)
+          argument_nodes.each_with_object({}) do |node, obj|
+            case node.type
+            when :splat
+              # TODO
+              infer(node)
+            when :block_pass
+              obj[:block_argument] = infer(node.children.first)
+            else
+              obj[:arguments] ||= []
+              obj[:arguments].push(infer(node))
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/yoda/typing/inferencer/arguments_binder.rb

@@ -0,0 +1,24 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class ArgumentsBinder
+        # @return [Types::Generator]
+        attr_reader :generator
+
+        # @param generator [Types::Generator]
+        def initialize(generator:)
+          @generator = generator
+        end
+
+        # @param types [Array<RBS::MethodTypej>]
+        # @param arguments [Model::Parameters]
+        # @return [Hash{ Symbol => Types::Type }]
+        def bind(types:, arguments:)
+          binds = types.map { |type| ParameterBinder.new(arguments).bind(type: type, generator: generator) }
+          # @todo Select only one signature to bind arguments
+          binds.reduce({}) { |memo, bind| memo.merge!(bind.to_h) { |_key, v1, v2| generator.union_type(v1, v2) } }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/inferencer/load_resolver.rb

@@ -0,0 +1,37 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class LoadResolver
+        # @return [Store::Project]
+        attr_reader :project
+
+        # @param project [Store::Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @param path [String]
+        # @return [String, nil]
+        def resolve(path)
+          path_at_project = Services::LoadablePathResolver.new.find_loadable_path(project.project_load_paths, path)
+          return path_at_project if path_at_project
+
+          found_library = libraries.find do |gem|
+            gem.contain_requirable_file?(path)
+          end
+
+          found_library&.find_requirable_file(path)
+        end
+
+        def libraries
+          [
+            # In search priority order
+            project.dependency.loadable_gems,
+            project.dependency.std,
+            project.dependency.core
+          ].flatten.map { |lib| lib.with_project_connection(project: project) }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/inferencer/method_resolver.rb

@@ -0,0 +1,81 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class MethodResolver
+        # @return [Store::Registry]
+        attr_reader :registry
+
+        # @return [Types::Base]
+        attr_reader :receiver_type
+
+        # @return [Array<Types::Base>]
+        attr_reader :argument_types
+
+        # @return [String]
+        attr_reader :name
+
+        # @return [Types::Generator]
+        attr_reader :generator
+
+        # @return [true, false]
+        attr_reader :implicit_receiver
+
+        # @param registry [Store::Registry]
+        # @param receiver_type [Types::Base]
+        # @param argument_type[Array<Types::Base>]
+        # @param name [String]
+        # @param generator [Types::Generator]
+        # @param implicit_receiver [true, false]
+        def initialize(registry:, receiver_type:, argument_types:, name:, generator:, implicit_receiver: false)
+          @registry = registry
+          @receiver_type = receiver_type
+          @argument_type = argument_types
+          @name = name
+          @generator = generator
+          @implicit_receiver = implicit_receiver
+        end
+
+        # Generate block context for the candidate
+        # @param context [Contexts::BaseContext]
+        # @param block_param_node [::AST::Node]
+        # @return [Contexts::BaseContext]
+        def generate_block_context(context:, block_param_node:)
+          binds = ArgumentsBinder.new(generator: generator).bind(types: method_types, arguments: block_param_node.parameter)
+
+          Contexts::BlockContext.new(parent: context, registry: registry, receiver: context.receiver, binds: binds)
+        end
+
+        # @return [Types::Base]
+        def return_type
+          @return_type ||= begin
+            Types::Union.new(*method_candidates.map(&:type).map(&:return_type).map { |type| converter.convert_from_expression(type) })
+          end
+        end
+
+        # @return [Array<Types::Function>]
+        def method_types
+          @method_types ||= method_candidates.map(&:type).map { |type| converter.convert_from_expression(type) }
+        end
+
+        # @return [Array<FunctionSignatures::Base>]
+        def method_candidates
+          @method_candidates ||=
+            Store::Query::FindSignature.new(registry)
+                                       .select_on_multiple(receiver_candidates, name.to_s, visibility: implicit_receiver ? %i(private protected public) : %i(public))
+        end
+
+        # @return [Array<Store::Objects::NamespaceObject>]
+        def receiver_candidates
+          @receiver_candidates ||= ObjectResolver.new(registry: registry, generator: generator).call(receiver_type)
+        end
+
+        private
+
+        # @return [Types::Converter]
+        def converter
+          @converter ||= generator.build_converter(self_type: receiver_type)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/inferencer/object_resolver.rb

@@ -0,0 +1,55 @@
+module Yoda
+  module Typing
+    class Inferencer
+      # Find object for the given constraints.
+      class ObjectResolver
+        # @return [Store::Registry]
+        attr_reader :registry
+
+        # @return [Types::Generator]
+        attr_reader :generator
+
+        # @param registry [Store::Registry]
+        # @param generator [Types::Generator]
+        def initialize(registry:, generator:)
+          @registry = registry
+        end
+
+        # @param type [Types::Base]
+        # @return [Array<Store::Objects::Base>]
+        def call(type)
+          case type
+          when Types::Any
+            []
+          when Types::Var
+            type.ref ? call(type.ref) : []
+          when Types::Instance
+            [type.klass]
+          when Types::Union
+            type.types.map { |type| call(type) }.flatten
+          when Types::Generic
+            call(type.base)
+          when Types::AssociativeArray
+            [generator.hash_type]
+          when Types::Tuple
+            [generator.array_type]
+          else
+            []
+          end
+        end
+
+        # @param receiver_value [Model::Values::Base]
+        # @param parent [Contexts::Base]
+        # @return [Contexts::Base]
+        def generate_class_context(instance_type, parent:)
+          Contexts::NamespaceContext.new(
+            receiver_value: instance_value.singleton_class_value,
+            parent: parent,
+            registry: registry,
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/yoda/typing/inferencer/parameter_binder.rb

@@ -0,0 +1,176 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class ParameterBinder
+        # @return [Base]
+        attr_reader :parameter
+
+        # @param parameter [Base]
+        def initialize(parameter)
+          @parameter = parameter
+        end
+
+        # @param type [RBS::MethodType]
+        # @param generator [Types::Generator]
+        # @param self_type [RBS::Types::t]
+        # @return [TypeBinding]
+        def bind(type:, generator:)
+          method_type = generator.fresh_params_of_method_type(type)
+          BoundResult.new(type: method_type, parameter: parameter, generator: generator).type_binding
+        end
+
+        class BoundResult
+          # @return [RBS::MethodType]
+          attr_reader :type
+
+          # @return [Model::Parameters::Base]
+          attr_reader :parameter
+
+          # @return [Types::Generator]
+          attr_reader :generator
+
+          # @param type [RBS::MethodType]
+          # @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_binding
+            @type_binding ||= begin
+              bind = TypeBinding.new
+
+              bind_positional_parameters(bind)
+              bind_keyword_parameters(bind)
+              bind_block_parameter(bind)
+
+              bind
+            end
+          end
+
+          private
+
+          # @param bind [TypeBinding]
+          def bind_positional_parameters(bind)
+            # @example 
+            #   (x, y, *extra, z)
+            #   (string, integer, symbol, boolean, float)
+            #   =>
+            #   {x: string, y: integer, extra: [symbol, boolean], z: float}
+
+            required_param_types = type.type.required_positionals.map(&:type).map(&method(:wrap_rbs_type))
+            optional_param_types = type.type.optional_positionals.map(&:type).map(&method(:wrap_rbs_type))
+            trailing_param_types = type.type.trailing_positionals.map(&:type).map(&method(:wrap_rbs_type))
+            rest_param_type = type.type.rest_positionals&.type&.yield_self(&method(:wrap_rbs_type))
+
+            pre_types = required_param_types + optional_param_types
+            post_types = trailing_param_types
+
+            pre_types_remained = bind_params(bind, params: parameter.parameters, types: pre_types)
+            post_types_remained = bind_params(bind, params: parameter.post_parameters.reverse, types: post_types).reverse
+
+            rest_type = begin
+              if pre_types_remained.empty? && post_types_remained.empty?
+                rest_param_type || generator.array_type
+              else
+                # TODO: Bind tuple
+                generator.array_type
+              end
+            end
+
+            if parameter.rest_parameter
+              bind_param(bind, param: parameter.rest_parameter, type: rest_type)
+            end
+          end
+
+          # @param bind [TypeBinding]
+          def bind_keyword_parameters(bind)
+            type_hash = type.type.required_keywords.merge(type.type.optional_keywords).map do |(symbol, param)|
+              [symbol, wrap_rbs_type(param.type)]
+            end.to_h
+
+            parameter.keyword_parameters.each do |param|
+              type = begin
+                name = (param.respond_to?(:name) && param.name)
+                (name && type_hash.delete(name)) || generator.any_type
+              end
+
+              bind_param(bind, param: param, type: type)
+            end
+
+            rest_type = begin
+              if type_hash.empty?
+                type.type.rest_keywords&.type&.yield_self(&method(:wrap_rbs_type)) || generator.hash_type
+              else
+                generator.hash_type
+              end
+            end
+
+            if parameter.keyword_rest_parameter 
+              bind_param(bind, param: parameter.keyword_rest_parameter, type: rest_type)
+            end
+          end
+
+          # @param bind [TypeBinding]
+          def bind_block_parameter(bind)
+            block_type = type.block&.yield_self(&method(:wrap_rbs_type)) || generator.proc_type
+
+            if parameter.block_parameter
+              bind_param(bind, param: parameter.block_parameter, type: block_type)
+            end
+          end
+
+          # @param bind [TypeBinding]
+          # @param params [Array<Model::Parameters::Base>]
+          # @param types [Array<Types::Type>]
+          # @return [Array<Types::Type>] 
+          def bind_params(bind, params:, types:)
+            remained_params, remained_types = bind_params_as_possible(bind, params: params, types: types)
+
+            # Bind untyped to all remained parameters
+            remained_params.each { |param| bind_param(bind, param: param, type: generator.any_type) }
+
+            remained_types
+          end
+
+          # @param bind [TypeBinding]
+          # @param params [Array<Model::Parameters::Base>]
+          # @param types [Array<Types::Type>]
+          # @return [(Array<Symbol>, Array<Types::Type>)] 
+          def bind_params_as_possible(bind, params:, types:)
+            min_length = [params.length, types.length].min
+
+            min_length.times do |i|
+              bind_param(bind, param: params[i], type: types[i])
+            end
+
+            [params.drop(min_length), types.drop(min_length)]
+          end
+
+          # @param param [Model::Parameters::Base]
+          # @param type [Types::Type]
+          # @return [Hash{Symbol => Interface}]
+          def bind_param(bind, param:, type:)
+            case param.kind
+            when :named
+              bind.bind(param.name, type)
+            when :multiple
+              # @todo
+              {}
+            else
+              {}
+            end
+          end
+
+          def wrap_rbs_type(rbs_type)
+            rbs_type = type.propage_context_to(rbs_type) if type.respond_to?(:act_as_type_wrapper?)
+            generator.wrap_rbs_type(rbs_type)
+          end
+        end
+      end
+    end
+  end
+end