yoda-language-server 0.8.0 → 0.10.1

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

@@ -0,0 +1,15 @@
+module Yoda
+  module Typing
+    module Tree
+      class ConditionalLoop < Base
+        # @!method node
+        #   @return [AST::ConditionalLoopNode]
+
+        def infer_type
+          # TODO
+          infer_child(node.body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Yoda
+  module Typing
+    module Tree
+      class Constant < Base
+        # @!method node
+        #  @return [AST::ConstantNode]
+
+        def infer_type
+          query = context.constant_resolver.build_query_for_node(node, tracer: tracer)
+          if (base_query = query.base).is_a?(ConstantResolver::CodeQuery)
+            base_query.result_type = infer_child(base_query.node)
+          end
+
+          context.constant_resolver.resolve(query)
+        end
+      end
+    end
+  end
+end

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

@@ -2,9 +2,9 @@ module Yoda
   module Typing
     module Tree
       class ConstantAssignment < Base
-        def process
+        def infer_type
           # TODO
-          infer(node.children.last)
+          infer_child(node.content)
         end
       end
     end

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

@@ -0,0 +1,17 @@
+module Yoda
+  module Typing
+    module Tree
+      class Ensure < Base
+        # @!method node
+        #   @return [AST::EnsureNode]
+
+        # @return [Types::Type]
+        def infer_type
+          type = infer_child(node.body)
+          infer_child(node.ensure_body)
+          type
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,13 @@ module Yoda
   module Typing
     module Tree
       class For < Base
+        # @!method node
+        #   @return [AST::ForNode]
+
+        def infer_type
+          # TODO
+          infer_child(node.body)
+        end
       end
     end
   end

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

@@ -0,0 +1,32 @@
+module Yoda
+  module Typing
+    module Tree
+      class HashTree < Base
+        # @!method node
+        #   @return [AST::HashNode]
+
+        # @return [Types::Type]
+        def infer_type
+          hash = node.contents.each_with_object({}) do |node, memo|
+            case node.type
+            when :pair
+              case node.key.type
+              when :sym
+                memo[node.key.value.to_sym] = infer_child(node.value)
+              when :str
+                memo[node.key.value.to_s] = infer_child(node.value)
+              else
+                # TODO: Support other key types.
+              end
+            when :kwsplat
+              infer_child(node.content)
+              # TODO: merge infered result
+            end
+          end
+
+          generator.record_type(hash)
+        end
+      end
+    end
+  end
+end

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

@@ -2,14 +2,19 @@ module Yoda
   module Typing
     module Tree
       class If < Base
-        def type
-          infer_branch_nodes(node.children.slice(1..2).compact)
+        # @!method node
+        #   @return [AST::IfNode]
+
+        # @return [Types::Type]
+        def infer_type
+          infer_branch_nodes(node.children.first, node.children.slice(1..2).compact)
         end
 
-        # @param node [Array<::AST::Node>]
+        # @param branch_nodes [Array<::AST::Node>]
         # @return [Types::Base]
-        def infer_branch_nodes(nodes)
-          Types::Union.new(nodes.map { |node| infer(node) })
+        def infer_branch_nodes(condition_node, branch_nodes)
+          infer_child(condition_node)
+          generator.union_type(*branch_nodes.map { |node| infer_child(node) })
         end
       end
     end

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

@@ -0,0 +1,21 @@
+require 'yoda/typing/tree/literal_inferable'
+
+module Yoda
+  module Typing
+    module Tree
+      class InterpolationText < Base
+        include LiteralInferable
+
+        # @!method node
+        #   @return [AST::InterpolationTextNode]
+
+        # @return [Types::Type]
+        def infer_type
+          node.children.each { |node| infer_child(node) }
+
+          infer_literal(node)
+        end
+      end
+    end
+  end
+end

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

@@ -1,44 +1,16 @@
+require 'yoda/typing/tree/literal_inferable'
+
 module Yoda
   module Typing
     module Tree
       class Literal < Base
-        def type
-          type_for_literal_sexp(node.type)
-        end
+        include LiteralInferable
+
+        # @!method node
+        #  @return [AST::LiteralNode, AST::Node]
 
-        # @param sexp_type [::Symbol, nil]
-        # @return [Types::Base]
-        def type_for_literal_sexp(sexp_type)
-          case sexp_type
-          when :dstr, :str, :xstr, :string
-            generator.string_type
-          when :dsym, :sym
-            generator.symbol_type
-          when :array, :splat
-            generator.array_type
-          when :hash
-            generator.hash_type
-          when :irange, :erange
-            generator.range_type
-          when :regexp
-            generator.regexp_type
-          when :true
-            generator.true_type
-          when :false
-            generator.false_type
-          when :nil
-            generator.nil_type
-          when :int
-            generator.integer_type
-          when :float
-            generator.float_type
-          when :complex
-            generator.numeric_type
-          when :rational
-            generator.numeric_type
-          else
-            generator.any_type
-          end
+        def infer_type
+          infer_literal(node)
         end
       end
     end

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

@@ -0,0 +1,48 @@
+module Yoda
+  module Typing
+    module Tree
+      module LiteralInferable
+        # @param node [AST::Vnode]
+        # @return [Types::Base]
+        def infer_literal(node)
+          case node.type
+          when :dstr, :xstr
+            generator.string_type
+          when :str, :string
+            generator.string_type(node.value.to_s)
+          when :dsym
+            generator.symbol_type
+          when :sym
+            generator.symbol_type(node.value.to_sym)
+          when :array, :splat
+            generator.array_type
+          when :hash
+            generator.hash_type
+          when :irange, :erange
+            generator.range_type
+          when :regexp
+            generator.regexp_type
+          when :true
+            generator.true_type
+          when :false
+            generator.false_type
+          when :nil
+            generator.nil_type
+          when :int
+            generator.integer_type(node.value.to_i)
+          when :float
+            generator.float_type
+          when :complex
+            generator.numeric_type
+          when :rational
+            generator.numeric_type
+          when :empty
+            generator.nil_type
+          else
+            generator.any_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Yoda
+  module Typing
+    module Tree
+      class LocalExit < Base
+        # @!method node
+        #   @return [AST::SpecialCallNode]
+
+        def infer_type
+          # TODO
+          node.arguments[0] ? infer_child(node.arguments[0]) : generator.nil_type
+        end
+      end
+    end
+  end
+end

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

@@ -2,13 +2,13 @@ module Yoda
   module Typing
     module Tree
       class LogicalAssignment < Base
-        def children
-          @children = node.children.map(&method(:build_child))
-        end
+        # @!method node
+        #   @return [AST::AssignmentNode]
 
-        def type
+        # @return [Types::Type]
+        def infer_type
           # TODO
-          infer(node.children.last)
+          infer_child(node.content)
         end
       end
     end

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

@@ -2,12 +2,13 @@ module Yoda
   module Typing
     module Tree
       class LogicalOperator < Base
-        def children
-          @children = node.children.map(&method(:build_child))
-        end
+        # @!method node
+        #   @return [AST::LeftOperatorNode, AST::CenterOperatorNode]
 
-        def type
-          Types::Union.new(node.children.map { |node| infer(node) })
+        # @return [Types::Type]
+        def infer_type
+          # TODO
+          generator.union_type(*node.children.map { |node| infer_child(node) })
         end
       end
     end

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

@@ -0,0 +1,41 @@
+require 'yoda/typing/tree/method_inferable'
+
+module Yoda
+  module Typing
+    module Tree
+      class MethodDef < Base
+        include MethodInferable
+
+        # @!method node
+        #   @return [AST::DefNode]
+
+        # @return [Types::Base]
+        def infer_type
+          infer_method_type(receiver_type: self_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 self_type
+          @self_type ||= begin
+            context.method_receiver
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Yoda
+  module Typing
+    module Tree
+      module MethodInferable
+        # @param receiver_type [Types::Type]
+        # @return [Types::Type]
+        def infer_method_type(receiver_type:)
+          value_resolve_context = generator.value_resolve_context(self_type: receiver_type)
+
+          method_candidates = receiver_type.value.select_method(node_name.to_s, visibility: %i(private protected public))
+          method_types = method_candidates.map(&:rbs_type).map { |type| value_resolve_context.wrap(type) }
+
+          # TODO: Support overloads
+          method_bind = method_types.reduce({}) do |all_bind, method_type|
+            bind = Inferencer::ParameterBinder.new(parameters_node.parameter).bind(type: method_type, generator: generator)
+            all_bind.merge(bind.to_h) { |_key, v1, v2| generator.union_type(v1, v2) }
+          end
+
+          Logger.trace("method_candidates: [#{method_candidates.join(', ')}]")
+          Logger.trace("bind arguments: #{method_bind.map { |key, value| [key, value.to_s] }.to_h }")
+
+          bind_method_definition(node: node, method_candidates: method_candidates)
+
+          method_context = context.derive_method_context(receiver_type: receiver_type, binds: method_bind)
+
+          infer_child(body_node, context: method_context)
+
+          generator.symbol_type(node_name.to_sym)
+        end
+
+        # @abstract
+        # @return [Symbol, string]
+        def node_name
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [AST::ParametersNode]
+        def parameters_node
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [AST::ParametersNode]
+        def body_node
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -1,29 +1,16 @@
+require 'yoda/typing/tree/namespace_inferable'
+
 module Yoda
   module Typing
     module Tree
       class ModuleTree < Base
-        def type
-          infer_namespace_node(node)
-        end
-
-        # @param node [::AST::Node]
-        # @return [Types::Base]
-        def infer_namespace_node(node)
-          case node.type
-          when :module
-            name_node, block_node = node.children
-          when :class
-            name_node, _, block_node = node.children
-          end
-          constant_resolver = ConstantResolver.new(context: context, node: name_node)
-          type = constant_resolver.resolve_constant_type
-          block_context = NamespaceContext.new(objects: [constant_resolver.constant], parent: context, registry: context.registry, receiver: type)
+        include NamespaceInferable
 
-          if block_node
-            derive(context: block_context).infer(block_node)
-          end
+        # @!method node
+        #   @return [AST::ModuleNode]
 
-          type
+        def infer_type
+          infer_namespace
         end
       end
     end

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

@@ -2,17 +2,13 @@ module Yoda
   module Typing
     module Tree
       class MultipleAssignment < 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)
-          body_type
+        # @return [Types::Type]
+        def infer_type
+          # TODO
+          infer_child(node.content)
         end
       end
     end

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

@@ -0,0 +1,20 @@
+module Yoda
+  module Typing
+    module Tree
+      module NamespaceInferable
+        # @!method node
+        #   @return [AST::ModuleNode, AST::ClassNode]
+
+        # @return [Types::Type]
+        def infer_namespace
+          namespace_type = infer_child(node.receiver)
+
+          new_context = context.derive_class_context(class_type: namespace_type)
+          infer_child(node.body, context: new_context)
+
+          namespace_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Yoda
+  module Typing
+    module Tree
+      class Rescue < Base
+        # @!method node
+        #   @return [AST::RescueNode]
+
+        # @return [Types::Base]
+        def infer_type
+          type = infer_child(node.body)
+          node.rescue_clauses.each { |rescue_clause| infer_child(rescue_clause) }
+          infer_child(node.else_clause)
+          type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Yoda
+  module Typing
+    module Tree
+      class RescueClause < Base
+        # @!method node
+        #   @return [AST::RescueClauseNode]
+
+        # @return [Types::Type]
+        def infer_type
+          binds = {}
+
+          exception_type = begin
+            if node.match_clause
+              case node.match_clause.type
+              when :array
+                generator.union_type(*node.match_clause.contents.map { |content| infer_child(content).instance_type })
+              when :empty
+                generator.standard_error_type
+              else
+                # Unexpected
+                generator.standard_error_type
+              end
+            else
+              generator.standard_error_type
+            end
+          end
+
+
+          if node.assignee
+            case node.assignee.type
+            when :lvasgn
+              binds[node.assignee.assignee.name] = exception_type
+            end
+          end
+
+          new_context = context.derive_block_context(binds: binds)
+          infer_child(node.body, context: new_context)
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,8 @@ module Yoda
   module Typing
     module Tree
       class Self < Base
-        def type
+        # @return [Types::Type]
+        def infer_type
           context.receiver
         end
       end

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