yoda-language-server 0.7.2 → 0.10.0

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

@@ -0,0 +1,209 @@
+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 => Tree::Base }]
+        attr_reader :node_to_tree
+
+        # @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
+
+        # @return [Hash{ AST::Node => Array<String> }]
+        attr_reader :node_to_require_paths
+
+        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_tree = 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
+          @node_to_require_paths = MaskedMap.new
+        end
+
+        # @param node [AST::Node]
+        # @param tree [Tree::Base]
+        def bind_tree(node:, tree:)
+          node_to_tree[node.identifier] = tree
+        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]
+        # @param require_paths [Array<String>]
+        def bind_require_paths(node:, require_paths:)
+          node_to_require_paths[node.identifier] = require_paths
+        end
+
+        # @param node [AST::Node]
+        # @return [Symbol, nil]
+        def kind(node)
+          node_to_kind[node.identifier]
+        end
+
+        # @param node [AST::Node]
+        # @return [Tree::Base, nil]
+        def tree(node)
+          node_to_tree[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 [Array<String>]
+        def require_paths(node)
+          node_to_require_paths[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,53 @@
+module Yoda
+  module Typing
+    class Inferencer
+      require 'yoda/typing/inferencer/arguments_binder'
+      require 'yoda/typing/inferencer/arguments'
+      require 'yoda/typing/inferencer/load_resolver'
+      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)
+        Tree.build(node, context: context, tracer: tracer).type
+      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,83 @@
+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 [Array<String>]
+      def require_paths
+        tracer.require_paths(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/ask_defined.rb

@@ -0,0 +1,12 @@
+module Yoda
+  module Typing
+    module Tree
+      class AskDefined < Base
+        # @return [Types::Type]
+        def infer_type
+          generator.boolean_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'forwardable'
+require 'pp'
+
+module Yoda
+  module Typing
+    module Tree
+      # @abstract
+      class Base
+        extend Forwardable
+
+        # @return [AST::Vnode]
+        attr_reader :node
+
+        # @return [Inferencer::Tracer]
+        attr_reader :tracer
+
+        # @return [Contexts::BaseContext]
+        attr_reader :context
+
+        delegate [:bind_tree, :bind_context, :bind_type, :bind_send, :bind_method_definition, :bind_require_paths] => :tracer
+
+        # @return [Types::Generator]
+        delegate [:generator] => :context
+
+        # @param node [AST::Vnode]
+        # @param tracer [Inferencer::Tracer]
+        # @param context [Contexts::BaseContext]
+        # @param parent [Base, nil]
+        def initialize(node:, tracer:, context:, parent: nil)
+          @node = node
+          @tracer = tracer
+          @context = context
+          @parent = parent
+        end
+
+        # @return [Types::Type]
+        def type
+          @type ||= begin
+            bind_tree(node: node, tree: self)
+            bind_context(node: node, context: context)
+            Logger.trace("Traversing #{node}")
+            type = infer_type
+            Logger.trace("Traversed #{node} -> #{type.to_s}")
+            bind_type(node: node, type: type, context: context)
+
+            type
+          end
+        end
+
+        # @param node [AST::Vnode]
+        # @return [Base]
+        def build_child(node, context: self.context)
+          Tree.build(node, context: context, tracer: tracer, parent: self)
+        end
+
+        # @param node [AST::Vnode]
+        # @param (see #build_child)
+        # @return [Types::Type]
+        def infer_child(node, **kwargs)
+          build_child(node, **kwargs).type
+        end
+
+        # @param pp [PP]
+        def pretty_print(pp)
+          pp.object_group(self) do
+            pp.breakable
+            pp.text "@node="
+            pp.pp node
+            pp.text "@context="
+            pp.pp context
+            pp.comma_breakable
+            pp.text "@tracer="
+            pp.pp tracer
+          end
+        end
+
+        def inspect
+          pretty_print_inspect
+        end
+
+        private
+
+        # @abstract
+        # @return [Types::Type]
+        def infer_type
+          fail NotImplementedError
+        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
+        # @!method node
+        #   @return [AST::BlockNode]
+
+        # @return [Types::Type]
+        def infer_type
+          node.children.map { |node| infer_child(node) }.last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'yoda/typing/tree/send_inferable'
+
+module Yoda
+  module Typing
+    module Tree
+      class BlockCall < Base
+        include SendInferable
+
+        # @!method node
+        #   @return [AST::BlockCallNode]
+
+        # @return [Types::Type]
+        def infer_type
+          if node.send_clause.type == :send
+            infer_send(node.send_clause, node.parameters, node.body)
+          else
+            # super or zsuper
+            child_type = infer_child(node.send_clause)
+            infer_child(node.body)
+            child_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Yoda
+  module Typing
+    module Tree
+      class Case < Base
+        # @!method node
+        #   @return [AST::CaseNode]
+
+        # @return [Type::Type]
+        def infer_type
+          subject_node, *when_nodes, else_node = node.children
+          infer_child(subject_node)
+          when_body_nodes = when_nodes.map { |node| node.children.last }
+          generator.union_type(*[*when_body_nodes, else_node].compact.map { |node| infer_child(node) })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'yoda/typing/tree/namespace_inferable'
+
+module Yoda
+  module Typing
+    module Tree
+      class ClassTree < Base
+        include NamespaceInferable
+
+        # @!method node
+        #   @return [AST::ClassNode]
+
+        # @return [Types::Base]
+        def infer_type
+          if super_class_node = node.super_class
+            infer_child(super_class_node)
+          end
+
+          infer_namespace
+        end
+      end
+    end
+  end
+end

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