yoda-language-server 0.9.0 → 0.10.0

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

@@ -1,69 +1,17 @@
+require 'yoda/typing/tree/send_inferable'
+
 module Yoda
   module Typing
     module Tree
       class Send < Base
-        def receiver
-          @receiver ||= node.children[0] && build_child(node.children[0])
-        end
-
-        # @return [Symbol]
-        def method_name
-          @method_name ||= node.children[1]
-        end
-
-        # @return [Symbol]
-        def arguments
-          @arguments ||= node.children.slice(2..-1).map(&method(:build_child))
-        end
-
-        # @param block_param_node [::AST::Node, nil]
-        # @param block_node [::AST::Node, nil]
-        # @return [Types::Base]
-        def infer_send_node(block_param_node = nil, block_node = nil)
-          if block_node
-            new_context = method_resolver.generate_block_context(context: context, block_param_node: block_param_node)
-            derive(context: new_context).infer(block_node)
-          end
-
-          tracer.bind_send(node: node, method_candidates: method_resolver.method_candidates, receiver_candidates: method_resolver.receiver_candidates)
-          method_resolver.return_type
-        end
-
-        def method_resolver
-          @method_resolver ||= MethodResolver.new(
-            registry: context.registry,
-            receiver_type: receiver_type,
-            name: method_name.to_s,
-            argument_types: argument_types,
-            generator: generator,
-            implicit_receiver: receiver.nil?,
-          )
-        end
-
-        def receiver_type
-          @receiver_type ||= receiver ? receiver.type : context.receiver
-        end
-
-        def block_context
-          @block_context ||= method_resolver.generate_block_context(context: context, block_param_node: block_param_node)
-        end
+        include SendInferable
 
-        private
+        # @!method node
+        #   @return [AST::SendNode]
 
-        # @return [{Symbol => Types::Base}]
-        def argument_types
-          @argument_types ||= argument_nodes.each_with_object({}) do |node, obj|
-            case node.type
-            when :splat
-              # TODO
-              node.type
-            when :blockarg
-              obj[:block_argument] = infer(node.children.first)
-            else
-              obj[:arguments] ||= []
-              obj[:arguments].push(node.type)
-            end
-          end
+        # @return [Types::Type]
+        def infer_type
+          infer_send(node)
         end
       end
     end

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

@@ -0,0 +1,89 @@
+module Yoda
+  module Typing
+    module Tree
+      module SendInferable
+        private
+
+        # @param send_node [AST::SendNode]
+        # @param block_param_node [AST::ParametersNode, nil]
+        # @param block_node [AST::Vnode, nil]
+        # @return [Types::Type]
+        def infer_send(send_node, block_param_node = nil, block_node = nil)
+          receiver_type = send_node.implicit_receiver? ? context.receiver : infer_child(send_node.receiver)
+          argument_map = infer_argument_nodes(send_node.arguments)
+          value_resolve_context = generator.value_resolve_context(self_type: receiver_type)
+
+          visibility = send_node.implicit_receiver? ? %i(private protected public) : %i(public)
+          # TODO: Support overloads
+          method_candidates = receiver_type.value.select_method(send_node.selector_name, visibility: visibility)
+          method_types = method_candidates.map(&:rbs_type).map { |type| value_resolve_context.wrap(type) }
+
+          if block_node
+            # TODO: Resolve type variables by matching argument_types with arguments
+            binds = Inferencer::ArgumentsBinder.new(generator: generator).bind(types: method_types, arguments: block_param_node.parameter)
+            new_context = context.derive_block_context(binds: binds)
+            infer_child(block_node, context: new_context)
+          end
+
+          Logger.trace("method_candidates: [#{method_candidates.join(', ')}]")
+          Logger.trace("receiver_type: #{receiver_type}")
+
+          bind_send(node: node, method_candidates: method_candidates, receiver_type: receiver_type)
+          resolve_require(method_candidates, argument_map)
+
+          if method_types.empty?
+            generator.unknown_type(reason: "method not found")
+          else
+            generator.union_type(*method_types.map { |method_type| value_resolve_context.wrap(method_type.type.return_type) })
+          end
+        end
+
+        # @param method_candidates [Array<Model::FunctionSignatures::Wrapper>]
+        # @param argument_map [{Symbol => Tree}]
+        def resolve_require(method_candidates, argument_map)
+          return unless method_candidates.any? { |method_candidate| method_candidate.name.to_s == "require" && method_candidate.namespace_path.to_s == "Kernel" }
+
+          first_argument_tree = argument_map[:arguments]&.first
+          return unless first_argument_tree
+
+          first_argument_type = first_argument_tree.type
+          strings = gather_literals(first_argument_type.value).select { |literal| literal.is_a?(String) }
+
+          require_paths = strings.map { |path| Inferencer::LoadResolver.new(context.environment.registry.project).resolve(path) }.compact
+          bind_require_paths(node: first_argument_tree.node, require_paths: require_paths)
+        end
+
+        # @param arguments [Array<AST::Vnode>]
+        # @return [{Symbol => Tree}]
+        def infer_argument_nodes(arguments)
+          arguments.each_with_object({}) do |node, obj|
+            case node.type
+            when :splat
+              # TODO
+              infer_child(node)
+            when :block_pass
+              obj[:block_argument] = build_child(node.children.first).tap(&:type)
+            else
+              obj[:arguments] ||= []
+              obj[:arguments].push(build_child(node).tap(&:type))
+            end
+          end
+        end
+
+        # @param value [Model::Values::Base]
+        # @return [Array<Object>]
+        def gather_literals(value)
+          if value.respond_to?(:literal)
+            [value.literal]
+          elsif value.respond_to?(:values)
+            value.values.flat_map { |v| gather_literals(v) }
+          elsif value.respond_to?(:value)
+            gather_literals(value.value)
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'yoda/typing/tree/namespace_inferable'
+
+module Yoda
+  module Typing
+    module Tree
+      class SingletonClassTree < Base
+        include NamespaceInferable
+
+        # @!method node
+        #   @return [AST::SingletonClassNode]
+
+        # @return [Types::Type]
+        def infer_type
+          receiver_type = infer_child(node.receiver)
+
+          new_context = context.derive_class_context(class_type: receiver_type.singleton_type)
+          infer_child(node.body, context: new_context)
+
+          generator.nil_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'yoda/typing/tree/method_inferable'
+
+module Yoda
+  module Typing
+    module Tree
+      class SingletonMethodDef < Base
+        include MethodInferable
+
+        # @!method node
+        #   @return [AST::DefSingletonNode]
+
+        # @return [Types::Base]
+        def infer_type
+          infer_method_type(receiver_type: receiver_type)
+        end
+
+        # @return [Symbol]
+        def node_name
+          node.name
+        end
+
+        # @return [AST::ParametersNode]
+        def parameters_node
+          node.parameters
+        end
+
+        # @return [Types::Type]
+        def body_node
+          node.body
+        end
+
+        # @return [Types::Type]
+        def receiver_type
+          @receiver_type ||= begin
+            infer_child(node.receiver)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,10 +1,17 @@
+require 'yoda/typing/tree/literal_inferable'
+
 module Yoda
   module Typing
     module Tree
       class Super < Base
-        def type
+        include LiteralInferable
+
+        # @!method node
+        #   @return [AST::SpecialCallNode]
+
+        def infer_type
           # TODO
-          generator.any_type
+          infer_literal(node)
         end
       end
     end

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

@@ -2,17 +2,12 @@ module Yoda
   module Typing
     module Tree
       class Variable < Base
-        def type
-          context.environment.resolve(node.children.first) || generator.any_type
-        end
+        # @!method node
+        #   @return [AST::VariableNode]
 
-        # @param var [Symbol]
-        # @param body_node [::AST::Node]
-        # @return [Store::Types::Base]
-        def process_bind(var, body_node)
-          body_type = infer(body_node)
-          context.environment.bind(var, body_type)
-          body_type
+        # @return [Types::Type]
+        def infer_type
+          context.type_binding.resolve(node.name) || generator.any_type
         end
       end
     end

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

@@ -2,18 +2,21 @@ module Yoda
   module Typing
     module Tree
       class VariableAssignment < Base
-        def process
-          process_bind(node.children[0], node.children[1])
-        end
+        # @!method node
+        #   @return [AST::AssignmentNode]
 
-        # @param var [Symbol]
-        # @param body_node [::AST::Node]
         # @return [Store::Types::Base]
-        def process_bind(var, body_node)
-          body_type = infer(body_node)
-          context.environment.bind(var, body_type)
+        def infer_type
+          context.type_binding.bind(node.assignee.name, body_type)
           body_type
         end
+
+        # @return [Types::Type]
+        def body_type
+          @body_type ||= begin
+            infer_child(node.content)
+          end
+        end
       end
     end
   end

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

@@ -1,10 +1,17 @@
+require 'yoda/typing/tree/literal_inferable'
+
 module Yoda
   module Typing
     module Tree
       class Yield < Base
-        def type
+        include LiteralInferable
+
+        # @!method node
+        #   @return [AST::SpecialCallNode]
+
+        def infer_type
           # TODO
-          generator.any_type
+          infer_literal(node)
         end
       end
     end

data/lib/yoda/typing/tree.rb

@@ -1,14 +1,41 @@
 module Yoda
   module Typing
     module Tree
-      require 'yoda/typing/inferencer/arguments_binder'
-      require 'yoda/typing/inferencer/contexts'
-      require 'yoda/typing/inferencer/environment'
-      require 'yoda/typing/inferencer/constant_resolver'
-      require 'yoda/typing/inferencer/method_resolver'
-      require 'yoda/typing/inferencer/method_definition_resolver'
-      require 'yoda/typing/inferencer/object_resolver'
-      require 'yoda/typing/inferencer/tracer'
+      require 'yoda/typing/tree/base'
+
+      require 'yoda/typing/tree/ask_defined'
+      require 'yoda/typing/tree/begin'
+      require 'yoda/typing/tree/block_call'
+      require 'yoda/typing/tree/case'
+      require 'yoda/typing/tree/class_tree'
+      require 'yoda/typing/tree/conditional_loop'
+      require 'yoda/typing/tree/constant_assignment'
+      require 'yoda/typing/tree/constant'
+      require 'yoda/typing/tree/ensure'
+      require 'yoda/typing/tree/for'
+      require 'yoda/typing/tree/hash_tree'
+      require 'yoda/typing/tree/if'
+      require 'yoda/typing/tree/interpolation_text'
+      require 'yoda/typing/tree/literal_inferable'
+      require 'yoda/typing/tree/literal'
+      require 'yoda/typing/tree/local_exit'
+      require 'yoda/typing/tree/logical_assignment'
+      require 'yoda/typing/tree/logical_operator'
+      require 'yoda/typing/tree/method_def'
+      require 'yoda/typing/tree/method_inferable'
+      require 'yoda/typing/tree/module_tree'
+      require 'yoda/typing/tree/multiple_assignment'
+      require 'yoda/typing/tree/namespace_inferable'
+      require 'yoda/typing/tree/rescue_clause'
+      require 'yoda/typing/tree/rescue'
+      require 'yoda/typing/tree/self'
+      require 'yoda/typing/tree/send'
+      require 'yoda/typing/tree/singleton_class_tree'
+      require 'yoda/typing/tree/singleton_method_def'
+      require 'yoda/typing/tree/super'
+      require 'yoda/typing/tree/variable_assignment'
+      require 'yoda/typing/tree/variable'
+      require 'yoda/typing/tree/yield'
 
       class << self
         # @param node [::AST::Node]
@@ -34,7 +61,7 @@ module Yoda
           when :if
             If
           when :while, :until, :while_post, :until_post
-            While
+            ConditionalLoop
           when :for
             For
           when :case
@@ -44,35 +71,41 @@ module Yoda
           when :yield
             Yield
           when :return, :break, :next
-            Escape
+            LocalExit
+          when :ensure
+            Ensure
+          when :rescue
+            Rescue
           when :resbody
-            RescueBody
+            RescueClause
           when :csend, :send
             Send
           when :block
-            Block
+            BlockCall
           when :const
-            Const
+            Constant
           when :lvar, :cvar, :ivar, :gvar
             Variable
-          when :begin, :kwbegin
+          when :begin, :kwbegin, :block
             Begin
           when :dstr, :dsym, :xstr
-            LiteralWithInterpolation
+            InterpolationText
           when :def
-            Method
+            MethodDef
           when :defs
-            SingletonMethod
+            SingletonMethodDef
           when :hash
-            HashBody
+            HashTree
           when :self
             Self
-          when :defined
-            Defined
-          when :module
-            ModuleTree
+          when :defined?
+            AskDefined
           when :class
             ClassTree
+          when :module
+            ModuleTree
+          when :sclass
+            SingletonClassTree
           else
             Literal
           end

data/lib/yoda/typing.rb

@@ -7,6 +7,7 @@ module Yoda
     require 'yoda/typing/traces'
     require 'yoda/typing/lexical_scope'
     require 'yoda/typing/types'
+    require 'yoda/typing/tree'
     require 'yoda/typing/inferencer'
     require 'yoda/typing/node_info'
   end

data/lib/yoda/version.rb

@@ -1,3 +1,3 @@
 module Yoda
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/yoda.rb

@@ -8,6 +8,7 @@ module Yoda
   require "yoda/ast"
   require "yoda/cli"
   require "yoda/errors"
+  require "yoda/id_mask"
   require "yoda/services"
   require "yoda/model"
   require "yoda/store"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yoda-language-server
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Tomoya Chiba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-21 00:00:00.000000000 Z
+date: 2022-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -389,6 +389,7 @@ files:
 - lib/yoda/cli/infer.rb
 - lib/yoda/errors.rb
 - lib/yoda/has_services.rb
+- lib/yoda/id_mask.rb
 - lib/yoda/instrument.rb
 - lib/yoda/logger.rb
 - lib/yoda/missing_delegatable.rb
@@ -399,6 +400,7 @@ files:
 - lib/yoda/model/descriptions/comment_token_description.rb
 - lib/yoda/model/descriptions/function_description.rb
 - lib/yoda/model/descriptions/node_description.rb
+- lib/yoda/model/descriptions/require_path_description.rb
 - lib/yoda/model/descriptions/value_description.rb
 - lib/yoda/model/descriptions/variable_description.rb
 - lib/yoda/model/descriptions/word_description.rb
@@ -538,6 +540,7 @@ files:
 - lib/yoda/services/current_node_explain.rb
 - lib/yoda/services/current_node_explain/comment_signature.rb
 - lib/yoda/services/evaluator.rb
+- lib/yoda/services/loadable_path_resolver.rb
 - lib/yoda/services/signature_discovery.rb
 - lib/yoda/store.rb
 - lib/yoda/store/actions.rb
@@ -565,6 +568,7 @@ files:
 - lib/yoda/store/objects/library.rb
 - lib/yoda/store/objects/library/core.rb
 - lib/yoda/store/objects/library/gem.rb
+- lib/yoda/store/objects/library/path_resolvable.rb
 - lib/yoda/store/objects/library/std.rb
 - lib/yoda/store/objects/library/with_registry.rb
 - lib/yoda/store/objects/map.rb
@@ -614,6 +618,7 @@ files:
 - lib/yoda/typing.rb
 - lib/yoda/typing/constant_resolver.rb
 - lib/yoda/typing/constant_resolver/cbase_query.rb
+- lib/yoda/typing/constant_resolver/code_query.rb
 - lib/yoda/typing/constant_resolver/member_query.rb
 - lib/yoda/typing/constant_resolver/node_tracer.rb
 - lib/yoda/typing/constant_resolver/query.rb
@@ -629,7 +634,7 @@ files:
 - lib/yoda/typing/inferencer.rb
 - lib/yoda/typing/inferencer/arguments.rb
 - lib/yoda/typing/inferencer/arguments_binder.rb
-- lib/yoda/typing/inferencer/ast_traverser.rb
+- lib/yoda/typing/inferencer/load_resolver.rb
 - lib/yoda/typing/inferencer/method_resolver.rb
 - lib/yoda/typing/inferencer/object_resolver.rb
 - lib/yoda/typing/inferencer/parameter_binder.rb
@@ -643,33 +648,40 @@ files:
 - lib/yoda/typing/traces/normal.rb
 - lib/yoda/typing/traces/send.rb
 - lib/yoda/typing/tree.rb
+- lib/yoda/typing/tree/ask_defined.rb
 - lib/yoda/typing/tree/base.rb
 - lib/yoda/typing/tree/begin.rb
-- lib/yoda/typing/tree/block.rb
+- lib/yoda/typing/tree/block_call.rb
 - lib/yoda/typing/tree/case.rb
 - lib/yoda/typing/tree/class_tree.rb
-- lib/yoda/typing/tree/const.rb
+- lib/yoda/typing/tree/conditional_loop.rb
+- lib/yoda/typing/tree/constant.rb
 - lib/yoda/typing/tree/constant_assignment.rb
-- lib/yoda/typing/tree/defined.rb
-- lib/yoda/typing/tree/escape.rb
+- lib/yoda/typing/tree/ensure.rb
 - lib/yoda/typing/tree/for.rb
-- lib/yoda/typing/tree/hash_body.rb
+- lib/yoda/typing/tree/hash_tree.rb
 - lib/yoda/typing/tree/if.rb
+- lib/yoda/typing/tree/interpolation_text.rb
 - lib/yoda/typing/tree/literal.rb
-- lib/yoda/typing/tree/literal_with_interpolation.rb
+- lib/yoda/typing/tree/literal_inferable.rb
+- lib/yoda/typing/tree/local_exit.rb
 - lib/yoda/typing/tree/logical_assignment.rb
 - lib/yoda/typing/tree/logical_operator.rb
-- lib/yoda/typing/tree/method.rb
+- lib/yoda/typing/tree/method_def.rb
+- lib/yoda/typing/tree/method_inferable.rb
 - lib/yoda/typing/tree/module_tree.rb
 - lib/yoda/typing/tree/multiple_assignment.rb
-- lib/yoda/typing/tree/rescue_body.rb
+- lib/yoda/typing/tree/namespace_inferable.rb
+- lib/yoda/typing/tree/rescue.rb
+- lib/yoda/typing/tree/rescue_clause.rb
 - lib/yoda/typing/tree/self.rb
 - lib/yoda/typing/tree/send.rb
-- lib/yoda/typing/tree/singleton_method.rb
+- lib/yoda/typing/tree/send_inferable.rb
+- lib/yoda/typing/tree/singleton_class_tree.rb
+- lib/yoda/typing/tree/singleton_method_def.rb
 - lib/yoda/typing/tree/super.rb
 - lib/yoda/typing/tree/variable.rb
 - lib/yoda/typing/tree/variable_assignment.rb
-- lib/yoda/typing/tree/while.rb
 - lib/yoda/typing/tree/yield.rb
 - lib/yoda/typing/types.rb
 - lib/yoda/typing/types/any.rb