yoda-language-server 0.7.0 → 0.8.0

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

@@ -0,0 +1,29 @@
+module Yoda
+  module Typing
+    module Tree
+      class Case < Base
+        # @return [[Store::Types::Base, Environment]]
+        def infer_case_node
+          # TODO
+          Types::Union.new([*when_body_nodes, else_node].map { |node| infer(node) })
+        end
+
+        def children
+          @children ||= [subject, *when_branches, else_branch]
+        end
+
+        def subject
+          @subject ||= build_child(node.children.first)
+        end
+
+        def when_branches
+          @when_branches ||= node.children.slice(1, -2).map(&method(:build_child))
+        end
+
+        def else_branch
+          @else_branch ||= build_child(node.children.last)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Yoda
+  module Typing
+    module Tree
+      class ClassTree < 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)
+
+          if block_node
+            derive(context: block_context).infer(block_node)
+          end
+
+          type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class Const < Base
+        def type
+          # TODO
+          infer(node.children.last)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class ConstantAssignment < Base
+        def process
+          # TODO
+          infer(node.children.last)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Yoda
+  module Typing
+    module Tree
+      class Escape < Base
+        def type
+          generator.boolean_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class Escape < Base
+        def type
+          # TODO
+          node.children[0] ? infer(node.children[0]) : generator.nil_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Yoda
+  module Typing
+    module Tree
+      class For < Base
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Yoda
+  module Typing
+    module Tree
+      class HashBody < Base
+        def type
+          infer_hash_node(node)
+        end
+
+        # @param node [::AST::Node]
+        # @return [Model::TypeExpressions::Base]
+        def infer_hash_node(node)
+          hash = node.children.each_with_object({}) do |node, memo|
+            case node.type
+            when :pair
+              pair_key, pair_value = node.children
+              case pair_key.type
+              when :sym
+                memo[pair_key.children.first.to_sym] = infer(pair_value)
+              when :str
+                memo[pair_key.children.first.to_s] = infer(pair_value)
+              else
+                # TODO: Support other key types.
+              end
+            when :kwsplat
+              content_node = node.children.first
+              content_type = infer(content_node)
+              # TODO: merge infered result
+            end
+          end
+
+          Types::AssociativeArray.new(contents: hash)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Yoda
+  module Typing
+    module Tree
+      class If < Base
+        def type
+          infer_branch_nodes(node.children.slice(1..2).compact)
+        end
+
+        # @param node [Array<::AST::Node>]
+        # @return [Types::Base]
+        def infer_branch_nodes(nodes)
+          Types::Union.new(nodes.map { |node| infer(node) })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Yoda
+  module Typing
+    module Tree
+      class Literal < Base
+        def type
+          type_for_literal_sexp(node.type)
+        end
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Yoda
+  module Typing
+    module Tree
+      class LiteralWithInterpolation < Base
+        def children
+          @children ||= node.children.map(&method(:build_child))
+        end
+
+        def type
+          children.map(&:type)
+          case node.type
+          when :xstr, :dstr
+            generator.string_type
+          when :dsym
+            generator.symbol_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Yoda
+  module Typing
+    module Tree
+      class LogicalAssignment < Base
+        def children
+          @children = node.children.map(&method(:build_child))
+        end
+
+        def type
+          # TODO
+          infer(node.children.last)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Yoda
+  module Typing
+    module Tree
+      class LogicalOperator < Base
+        def children
+          @children = node.children.map(&method(:build_child))
+        end
+
+        def type
+          Types::Union.new(node.children.map { |node| infer(node) })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Yoda
+  module Typing
+    module Tree
+      class Method < Base
+        def name
+          node.children.first
+        end
+
+        def argument
+          @argument ||= build_child(node.children[1])
+        end
+
+        def body
+          @body ||= node.children[2] && build_child(node.children[2], context: method_context)
+        end
+
+        # @return [Types::Base]
+        def type
+          @type ||= generator.symbol_type
+        end
+
+        def receiver_type
+          @receiver_type ||= generator.union(context.current_objects.map { |object| generator.object_type(object) })
+        end
+
+        def method_context
+          @method_context ||= method_definition_provider.generate_method_context(context: context, args_node: args_node)
+        end
+
+        private
+
+        def method_definition_provider
+          @method_definition_provider ||= MethodDefinitionResolver.new(
+            receiver_type: receiver_type,
+            name: name,
+            registry: context.registry,
+            generator: generator,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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)
+
+          if block_node
+            derive(context: block_context).infer(block_node)
+          end
+
+          type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Yoda
+  module Typing
+    module Tree
+      class MultipleAssignment < Base
+        def process
+          process_bind(node.children[0], node.children[1])
+        end
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class RescueBody < Base
+        def type
+          # TODO
+          infer(node.children[2])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Yoda
+  module Typing
+    module Tree
+      class Self < Base
+        def type
+          context.receiver
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+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
+
+        private
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Yoda
+  module Typing
+    module Tree
+      class SingletonMethod < Base
+        def receiver
+          node.children[0]
+        end
+
+        def name
+          node.children[1]
+        end
+
+        def argument
+          @argument ||= build_child(node.children[2])
+        end
+
+        def body
+          @body ||= node.children[3] && build_child(node.children[3], context: method_context)
+        end
+
+        # @return [Types::Base]
+        def type
+          @type ||= generator.symbol_type
+        end
+
+        def receiver_type
+          @receiver_type ||= receiver.type
+        end
+
+        def method_context
+          @method_context ||= method_definition_provider.generate_method_context(context: context, args_node: args_node)
+        end
+
+        private
+
+        def method_definition_provider
+          @method_definition_provider ||= MethodDefinitionResolver.new(
+            receiver_type: receiver_type,
+            name: name,
+            registry: context.registry,
+            generator: generator,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class Super < Base
+        def type
+          # TODO
+          generator.any_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Yoda
+  module Typing
+    module Tree
+      class Variable < Base
+        def type
+          context.environment.resolve(node.children.first) || generator.any_type
+        end
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Yoda
+  module Typing
+    module Tree
+      class VariableAssignment < Base
+        def process
+          process_bind(node.children[0], node.children[1])
+        end
+
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class While < Base
+        def type
+          # TODO
+          infer(node.children[1])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class Yield < Base
+        def type
+          # TODO
+          generator.any_type
+        end
+      end
+    end
+  end
+end