yoda-language-server 0.7.0 → 0.8.0

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

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

@@ -0,0 +1,177 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class Tracer
+        # @return [Model::Environment]
+        attr_reader :environment
+
+        # @return [Types::Generator]
+        attr_reader :generator
+
+        # @return [Hash{ AST::Node => Symbol }]
+        attr_reader :node_to_kind
+
+        # @return [Hash{ AST::Node => Types::Base }]
+        attr_reader :node_to_type
+
+        # @return [Hash{ AST::Node => Context }]
+        attr_reader :node_to_context
+
+        # @return [Hash{ AST::Node => Types::Type }]
+        attr_reader :node_to_receiver_type
+
+        # @return [Hash{ AST::Node => Array<FunctionSignatures::Base> }]
+        attr_reader :node_to_method_candidates
+
+        # @return [Hash{ AST::Node => Array<Store::Objects::Base> }]
+        attr_reader :node_to_constants
+
+        class MaskedMap
+          def initialize
+            @content = {}
+          end
+
+          def [](key)
+            @content[key]
+          end
+
+          def []=(key, value)
+            @content[key] = value
+          end
+
+          def to_s
+            inspect
+          end
+
+          def to_h
+            @content
+          end
+
+          def inspect
+            "(#{@content.length} items)"
+          end
+        end
+
+        # @param environment [Model::Environment]
+        # @param generator [Types::Generator]
+        def initialize(environment:, generator:)
+          @environment = environment
+          @generator = generator
+
+          @node_to_kind = MaskedMap.new
+          @node_to_type = MaskedMap.new
+          @node_to_context = MaskedMap.new
+          @node_to_method_candidates = MaskedMap.new
+          @node_to_receiver_type = MaskedMap.new
+          @node_to_constants = MaskedMap.new
+        end
+
+        # @param node [AST::Node]
+        # @param type [Types::Base]
+        # @param context [Contexts::BaseContext]
+        def bind_type(node:, type:, context:)
+          node_to_type[node.identifier] = type
+        end
+
+        # @param node [AST::Node]
+        # @param context [Contexts::BaseContext]
+        def bind_context(node:, context:)
+          node_to_context[node.identifier] = context
+        end
+
+        # @param variable [Symbol]
+        # @param type [Types::Base]
+        # @param context [Contexts::BaseContext]
+        def bind_local_variable(variable:, type:, context:)
+          # nop
+        end
+
+        # @param node [AST::Node]
+        # @param receiver_candidates [Array<Store::Objects::NamespaceObject>]
+        # @param method_candidates [Array<Model::FunctionSignatures::Base>]
+        def bind_send(node:, receiver_type:, method_candidates:)
+          fail TypeError, method_candidates unless method_candidates.all? { |candidate| candidate.is_a?(Model::FunctionSignatures::Wrapper) }
+
+          node_to_kind[node.identifier] = :send
+          node_to_receiver_type[node.identifier] = receiver_type
+          node_to_method_candidates[node.identifier] = method_candidates
+        end
+
+        # @param node [AST::Node]
+        # @param method_candidates [Array<Model::FunctionSignatures::Base>]
+        def bind_method_definition(node:, method_candidates:)
+          fail TypeError, method_candidates unless method_candidates.all? { |candidate| candidate.is_a?(Model::FunctionSignatures::Wrapper) }
+
+          node_to_kind[node.identifier] = :send
+          node_to_method_candidates[node.identifier] = method_candidates
+        end
+
+        # @param node [AST::Node]
+        # @param constants [Array<Store::Objects::Base>]
+        def bind_constants(node:, constants:)
+          node_to_constants[node.identifier] = constants
+        end
+
+        # @param node [AST::Node]
+        # @return [Symbol, nil]
+        def kind(node)
+          node_to_kind[node.identifier]
+        end
+
+        # @param node [AST::Node]
+        # @return [Types::Type]
+        def type(node)
+          node_to_type[node.identifier] || generator.unknown_type(reason: "not traced")
+        end
+
+        # @param node [AST::Node]
+        # @return [NodeInfo]
+        def node_info(node)
+          NodeInfo.new(node: node, tracer: self)
+        end
+
+        # @param node [AST::Node]
+        # @return [Array<Store::Objects::Base>]
+        def objects(node)
+          type(node).value.referred_objects
+        end
+
+        # @param node [AST::Node]
+        # @return [Types::Type]
+        def receiver_type(node)
+          node_to_receiver_type[node.identifier] || generator.unknown_type(reason: "not traced")
+        end
+
+        # @param node [AST::Node]
+        # @return [Array<FunctionSignatures::Wrapper>]
+        def method_candidates(node)
+          node_to_method_candidates[node.identifier] || []
+        end
+
+        # @param node [AST::Node]
+        # @return [Array<Store::Objects::Base>]
+        def constants(node)
+          node_to_constants[node.identifier] || []
+        end
+
+        # @param node [AST::Node]
+        # @return [Contexts::BaseContext, nil]
+        def context(node)
+          node_to_context[node.identifier]
+        end
+
+        # @param node [AST::Node]
+        # @return [Hash{ Symbol => Types::Base }]
+        def context_variable_types(node)
+          context(node)&.type_binding&.all_variables || {}
+        end
+
+        # @param node [AST::Node]
+        # @return [Hash{ Symbol => Store::Objects::Base }]
+        def context_variable_objects(node)
+          context(node)&.type_binding&.all_variables&.transform_values { |type| type.value.referred_objects } || {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Yoda
+  module Typing
+    class Inferencer
+      # Bindings of local variables
+      class TypeBinding
+        # @return [TypeBinding, nil]
+        attr_reader :parent
+
+        # @return [Hash{ Symbol => Types::Type}]
+        attr_reader :binds
+
+        # @param parent [Environment, nil]
+        # @param binds [Hash{ Symbol => Types::Type}, nil]
+        def initialize(parent: nil, binds: nil)
+          @parent = parent
+          @binds = (binds || {}).to_h
+        end
+
+        # @param key  [String, Symbol]
+        def resolve(key)
+          all_variables[key.to_sym]
+        end
+
+        # @param key  [String, Symbol]
+        # @param type [Symbol, Types::Type]
+        def bind(key, type)
+          key = key.to_sym
+          type = (type.is_a?(Symbol) && resolve(type)) || type
+          @binds.transform_values! { |value| value == key ? type : value }
+          @binds[key] = type
+          self
+        end
+
+        # @return [Hash{ Symbol => Types::Type }]
+        def to_h
+          all_variables
+        end
+
+        # @return [Hash{ Symbol => Types::Type }]
+        def all_variables
+          (parent&.all_variables || {}).merge(binds)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/inferencer.rb

@@ -0,0 +1,52 @@
+module Yoda
+  module Typing
+    class Inferencer
+      require 'yoda/typing/inferencer/arguments_binder'
+      require 'yoda/typing/inferencer/arguments'
+      require 'yoda/typing/inferencer/ast_traverser'
+      require 'yoda/typing/inferencer/method_resolver'
+      require 'yoda/typing/inferencer/object_resolver'
+      require 'yoda/typing/inferencer/parameter_binder'
+      require 'yoda/typing/inferencer/tracer'
+      require 'yoda/typing/inferencer/type_binding'
+
+      # @return [Contexts::BaseContext]
+      attr_reader :context
+
+      # @return [Tracer]
+      attr_reader :tracer
+
+      # @param environment [Model::Environment]
+      # @return [Inferencer]
+      def self.create_for_root(environment:)
+        context = Contexts.root_scope(environment: environment)
+        new(context: context)
+      end
+
+      # @param context [Contexts::BaseContext]
+      # @param tracer [Tracer, nil]
+      def initialize(context:, tracer: nil)
+        @context = context
+        @tracer = tracer || Tracer.new(environment: context.environment, generator: context.generator)
+      end
+
+      # @param node [AST::Vnode]
+      # @return [Store::Types::Base]
+      def infer(node)
+        AstTraverser.new(tracer: tracer, context: context).traverse(node)
+      end
+
+      # @param pp [PP]
+      def pretty_print(pp)
+        pp.object_group(self) do
+          pp.breakable
+          pp.text "@context="
+          pp.pp context
+          pp.comma_breakable
+          pp.text "@tracer="
+          pp.pp tracer
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/node_info.rb

@@ -0,0 +1,78 @@
+require 'forwardable'
+
+module Yoda
+  module Typing
+    # Facade for information of the specified node traced on inference
+    class NodeInfo
+      extend Forwardable
+
+      # @return [AST::Node]
+      attr_reader :node
+
+      # @return [Inferencer::Tracer]
+      attr_reader :tracer
+
+      delegate %i(location range) => :node
+
+      # @param node [AST::Node]
+      # @param tracer [Inferencer::Tracer]
+      def initialize(node:, tracer:)
+        @node = node
+        @tracer = tracer
+      end
+
+      # @return [Symbol]
+      def kind
+        tracer.kind(node) || node.type
+      end
+
+      # @return [Types::Type]
+      def receiver_type
+        tracer.receiver_type(node)
+      end
+
+      # @return [Array<FunctionSignatures::Base>]
+      def method_candidates
+        tracer.method_candidates(node)
+      end
+
+      # @return [Array<Store::Objects::Base>]
+      def constants
+        tracer.constants(node)
+      end
+
+      # @return [Types::Type]
+      def type
+        tracer.type(node)
+      end
+
+      # @return [Array<Store::Objects::Base>]
+      def objects
+        tracer.objects(node)
+      end
+
+      # @return [Array<Store::Objects::Base>]
+      def scope_objects
+        tracer.objects(node)
+      end
+
+      # @return [Array<Store::Objects::NamespaceObject>]
+      def lexical_scope_types
+        context&.lexical_scope_types || []
+      end
+
+      # @param path_expr [String]
+      # @return [Types::Type, nil]
+      def resolve_constant(path_expr)
+        context&.constant_resolver&.resolve_path(path_expr.to_s)
+      end
+
+      private
+
+      # @return [Contexts::BaseContext]
+      def context
+        tracer.context(node)
+      end
+    end
+  end
+end

data/lib/yoda/typing/relation.rb

@@ -2,8 +2,8 @@ module Yoda
   module Typing
     class Relation
       attr_reader :left, :right, :op
-      # @param left  [Symbol, Model::Types::Base]
-      # @param right [Symbol, Model::Types::Base]
+      # @param left  [Symbol, Model::TypeExpressions::Base]
+      # @param right [Symbol, Model::TypeExpressions::Base]
       # @param op    [Symbol]
       def initialize(left, right, op = :eq)
         @left = left

data/lib/yoda/typing/traces/base.rb

@@ -10,13 +10,13 @@ module Yoda
         end
 
         # @abstract
-        # @return [Model::Types::Base]
+        # @return [Model::TypeExpressions::Base]
         def type
           fail NotImplementedError
         end
 
         # @abstract
-        # @return [Context]
+        # @return [Contexts::BaseContext]
         def context
           fail NotImplementedError
         end

data/lib/yoda/typing/traces/normal.rb

@@ -5,10 +5,10 @@ module Yoda
       class Normal < Base
         attr_reader :context, :type
 
-        # @param context [Context]
-        # @param type    [Model::Types::Base]
+        # @param context [Contexts::BaseContext]
+        # @param type    [Model::TypeExpressions::Base]
         def initialize(context, type)
-          fail ArgumentError, type unless type.is_a?(Model::Types::Base)
+          fail ArgumentError, type unless type.is_a?(Model::TypeExpressions::Base)
           @context = context
           @type = type
         end

data/lib/yoda/typing/traces/send.rb

@@ -3,18 +3,18 @@ module Yoda
     module Traces
       # Store evaluation result for each ast node.
       class Send < Base
-        # @return [Context]
+        # @return [Contexts::BaseContext]
         attr_reader :context
 
         # @return [Array<Model::FunctionSignatures::Base>]
         attr_reader :functions
 
-        # @return [Model::Types::Base]
+        # @return [Model::TypeExpressions::Base]
         attr_reader :type
 
-        # @param context [Context]
+        # @param context [Contexts::BaseContext]
         # @param functions [Array<Model::FunctionSignatures::Base>]
-        # @param type [Array<Model::Types::Base>]
+        # @param type [Array<Model::TypeExpressions::Base>]
         def initialize(context, functions, type)
           @context = context
           @functions = functions

data/lib/yoda/typing/tree/base.rb

@@ -0,0 +1,46 @@
+module Yoda
+  module Typing
+    module Tree
+      # @abstract
+      class Base
+        # @return [::AST::Node]
+        attr_reader :node
+
+        # @return [BaseContext]
+        attr_reader :context
+
+        # @param node [::AST::Node]
+        # @param context [BaseContext]
+        # @param parent [Base, nil]
+        def initialize(node:, context:, parent: nil)
+          @node = node
+          @context = context
+          @parent = parent
+        end
+
+        # @abstract
+        # @return [Array<Base>]
+        def children
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Types::Base]
+        def type
+          fail NotImplementedError
+        end
+
+        # @return [Types::Generator]
+        def generator
+          @generator ||= Types::Generator.new(context.registry)
+        end
+
+        # @param node [::AST::Node]
+        # @return [Base]
+        def build_child(node, context: nil)
+          Tree.build(node, context: context, parent: self)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/tree/begin.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module Typing
+    module Tree
+      class Begin < Base
+        def children
+          @children ||= node.children.map(&method(:build_child))
+        end
+
+        def type
+          children.map(&:type).last
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/tree/block.rb

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class Block < Base
+        def type
+          send_node, arg_node, block_node = node
+          infer_send_node(send_node, arg_node, block_node)
+        end
+      end
+    end
+  end
+end