yoda-language-server 0.8.0 → 0.10.1

data/lib/yoda/store/project/file_finder.rb

@@ -49,6 +49,16 @@ module Yoda
           expand_path('.yoda.yml')
         end
 
+        # @return [Array<String>]
+        def project_source_paths
+          glob(["{lib,app}/**/*.rb", "ext/**/*.c", ".yoda/*.rb"])
+        end
+
+        # @return [Array<String>]
+        def project_load_paths
+          ["lib", "app", "ext"].map { |path| expand_path(path) }.compact
+        end
+
         # @return [String, nil]
         def readable_config_file_path
           path = config_file_path
@@ -95,6 +105,16 @@ module Yoda
         def make_dir_at(dir_path)
           dir_path && (File.exist?(dir_path) || FileUtils.mkdir_p(dir_path))
         end
+
+        # @param pattern [String, Array<String>]
+        # @return [Array<String>]
+        def glob(pattern, base_path = project.root_path)
+          if project.root_path
+            Dir.glob(pattern, base: base_path).map { |path| File.expand_path(path, base_path) }
+          else
+            []
+          end
+        end
       end
     end
   end

data/lib/yoda/store/project.rb

@@ -33,6 +33,8 @@ module Yoda
           :library_registry_dir_path,
           :gemfile_lock_path,
           :config_file_path,
+          :project_source_paths,
+          :project_load_paths,
           :readable_config_file_path,
           :library_local_yardoc_path,
           :library_registry_path,

data/lib/yoda/store/registry/cache.rb

@@ -19,9 +19,9 @@ module Yoda
           @cache = cache
         end
 
-        def get(key)
+        def get(key, **kwargs)
           @cache.fetch_or_calc(key) do
-            @registry.get(key)
+            @registry.get(key, **kwargs)
           end
         end
 

data/lib/yoda/store/registry/composer.rb

@@ -9,20 +9,22 @@ module Yoda
 
       def initialize(id:, registries: [])
         @id = id
-        @registries = registries.map { |registry| [registry.id, registry] }.to_h
+        @registries = registries.map { |registry| [registry.id.to_sym, registry] }.to_h
       end
 
       def add_registry(registry)
-        registries[registry.id] = registry
+        registries[registry.id.to_sym] = registry
       end
 
       def remove_registry(registry)
-        registries.delete(registry.id)
+        registries.delete(registry.id.to_sym)
       end
 
       def get(address, registry_ids: nil)
-        target_registries = registry_ids ? registry_ids.map { |id| get_registry(id) }.compact : all_registries
-        objects_in_registry = target_registries.map { |registry| registry.get(address) }.compact
+        registry_mask = IdMask.build(registry_ids)
+        target_registries = registry_mask.any? ? all_registries : registry_mask.covering_ids.map { |id| get_registry(id) }.compact
+
+        objects_in_registry = target_registries.map { |registry| registry.get(address, registry_ids: registry_mask.nesting_mask(registry.id)) }.compact
         objects_in_registry.empty? ? nil : Objects::Merger.new(objects_in_registry).merged_instance
       end
 
@@ -32,11 +34,11 @@ module Yoda
       end
 
       def get_registry(key)
-        registries[key]
+        registries[key.to_sym]
       end
 
       def has_registry(key)
-        registries.has_key?(key)
+        registries.has_key?(key.to_sym)
       end
 
       def all_registries

data/lib/yoda/store/registry/index.rb

@@ -25,10 +25,11 @@ module Yoda
           @composer = composer
         end
 
-        # @param [String, Symbol]
+        # @param address [String, Symbol]
+        # @param registry_ids [Array<String, Symbol>, nil] if given, search object only from the specified registries.
         # @return [Objects::Addressable]
-        def get(address)
-          composer.get(address, registry_ids: index.get(address))
+        def get(address, registry_ids: nil)
+          composer.get(address, registry_ids: index.get(address, registry_ids: registry_ids))
         end
 
         def add_registry(registry)
@@ -74,17 +75,20 @@ module Yoda
         @registry_ids = Set.new(registry_ids)
       end
 
+      # Return ids of registries which store an object with the address.
       # @param address [String, Symbol]
-      # @return [Set<Symbol>]
-      def get(address)
-        content[address.to_sym] ||= Objects::SerializableSet.new
+      # @param registry_ids [Array<String, Symbol>, IdMask, nil]
+      # @return [IdMask]
+      def get(address, registry_ids: nil)
+        raw_content = (content[address.to_sym] ||= Objects::SerializableSet.new)
+        registry_ids ? (IdMask.build(registry_ids) & raw_content) : raw_content
       end
 
       # @param address [String, Symbol]
       # @param registry_id [String, Symbol]
       def add(address, registry_id)
         content[address.to_sym] ||= Objects::SerializableSet.new
-        content[address.to_sym].add(registry_id)
+        content[address.to_sym].add(registry_id.to_sym)
         content[address.to_sym].select! { |id| registry_ids.member?(id) }
       end
 
@@ -92,7 +96,7 @@ module Yoda
       # @param registry_id [String, Symbol]
       def remove(address, registry_id)
         content[address.to_sym] ||= Objects::SerializableSet.new
-        content[address.to_sym].delete(registry_id)
+        content[address.to_sym].delete(registry_id.to_sym)
       end
 
       def keys
@@ -100,12 +104,12 @@ module Yoda
       end
 
       def add_registry(registry)
-        registry_ids.add(registry.id)
+        registry_ids.add(registry.id.to_sym)
         registry.keys.each { |key| add(key, registry.id) }
       end
 
       def remove_registry(registry)
-        registry_ids.delete(registry.id)
+        registry_ids.delete(registry.id.to_sym)
       end
 
       def wrap(composer)

data/lib/yoda/store/registry/library_registry.rb

@@ -8,8 +8,10 @@ module Yoda
           namespace = adapter.namespace(library.name)
 
           if namespace.empty?
+            Instrument.instance.build_library_registry(name: library.name, version: library.version, message: "Building registry for #{library.name} (#{library.version})")
             patch = library.create_patch
             patch && compress_and_save(patch: patch, adapter: namespace)
+            Instrument.instance.build_library_registry(name: library.name, version: library.version, message: "Finished to build registry for #{library.name} (#{library.version})")
           end
 
           new(id: library.id, adapter: namespace)
@@ -47,7 +49,7 @@ module Yoda
         @adapter = adapter
       end
 
-      def get(path)
+      def get(path, **)
         adapter.get(path)
       end
 

data/lib/yoda/store/registry.rb

@@ -12,7 +12,7 @@ module Yoda
       require 'yoda/store/registry/project_registry'
 
       # @note This number must be updated when breaking change is added.
-      REGISTRY_VERSION = 6
+      REGISTRY_VERSION = 7
 
       class << self
         def registry_name

data/lib/yoda/typing/constant_resolver/code_query.rb

@@ -0,0 +1,25 @@
+require 'yoda/typing/constant_resolver/query'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      class CodeQuery < Query
+        # @return [AST::Vnode]
+        attr_reader :node
+
+        # @return [Types::Type, nil]
+        attr_accessor :result_type
+
+        # @param node [AST::Vnode]
+        def initialize(node:)
+          @node = node
+        end
+
+        # @return [nil]
+        def parent
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/constant_resolver/query.rb

@@ -12,8 +12,10 @@ module Yoda
               CbaseQuery.new
             when :empty
               RelativeBaseQuery.new
-            else
+            when :const
               MemberQuery.new(parent: from_node(node.base, tracer: tracer), name: node.name.name.to_s, tracer: tracer && NodeTracer.new(node: node, tracer: tracer))
+            else
+              CodeQuery.new(node: node)
             end
           end
 
@@ -53,6 +55,15 @@ module Yoda
         def tracer
           nil
         end
+
+        # @return [Query]
+        def base
+          if parent
+            parent.base
+          else
+            self
+          end
+        end
       end
     end
   end

data/lib/yoda/typing/constant_resolver.rb

@@ -4,6 +4,7 @@ module Yoda
   module Typing
     class ConstantResolver
       require 'yoda/typing/constant_resolver/cbase_query'
+      require 'yoda/typing/constant_resolver/code_query'
       require 'yoda/typing/constant_resolver/member_query'
       require 'yoda/typing/constant_resolver/node_tracer'
       require 'yoda/typing/constant_resolver/query'
@@ -29,14 +30,6 @@ module Yoda
         Query.from_node(node, tracer: tracer)
       end
 
-      # @param node [AST::ConstantNode]
-      # @param tracer [Inferncer::Tracer]
-      # @return [Types::Base]
-      def resolve_node(node, tracer:)
-        query = Query.from_node(node, tracer: tracer)
-        resolve(query)
-      end
-
       # @param path [String]
       # @return [Types::Base]
       def resolve_path(path)
@@ -95,6 +88,18 @@ module Yoda
 
           query.tracer&.bind_constants(constants: constants)
 
+          generator.wrap_rbs_type(base_type.value.select_constant_type(query.name.to_s))
+        when CodeQuery
+          base_type = query.parent.result_type
+
+          fail "Result type is not set" unless base_type
+
+          # Remember constant candidates
+          paths = base_type.value.select_constant_paths(query.name.to_s)
+          constants = paths.map { |path| context.environment.resolve_constant(path) }.compact
+
+          query.tracer&.bind_constants(constants: constants)
+
           generator.wrap_rbs_type(base_type.value.select_constant_type(query.name.to_s))
         else
           fail "unexpected"

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

@@ -0,0 +1,37 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class LoadResolver
+        # @return [Store::Project]
+        attr_reader :project
+
+        # @param project [Store::Project]
+        def initialize(project)
+          @project = project
+        end
+
+        # @param path [String]
+        # @return [String, nil]
+        def resolve(path)
+          path_at_project = Services::LoadablePathResolver.new.find_loadable_path(project.project_load_paths, path)
+          return path_at_project if path_at_project
+
+          found_library = libraries.find do |gem|
+            gem.contain_requirable_file?(path)
+          end
+
+          found_library&.find_requirable_file(path)
+        end
+
+        def libraries
+          [
+            # In search priority order
+            project.dependency.loadable_gems,
+            project.dependency.std,
+            project.dependency.core
+          ].flatten.map { |lib| lib.with_project_connection(project: project) }
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,9 @@ module Yoda
         # @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
 
@@ -26,6 +29,9 @@ module Yoda
         # @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 = {}
@@ -59,11 +65,19 @@ module Yoda
           @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]
@@ -112,12 +126,24 @@ module Yoda
           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)
@@ -154,6 +180,12 @@ module Yoda
           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)

data/lib/yoda/typing/inferencer.rb

@@ -3,7 +3,7 @@ module Yoda
     class Inferencer
       require 'yoda/typing/inferencer/arguments_binder'
       require 'yoda/typing/inferencer/arguments'
-      require 'yoda/typing/inferencer/ast_traverser'
+      require 'yoda/typing/inferencer/load_resolver'
       require 'yoda/typing/inferencer/method_resolver'
       require 'yoda/typing/inferencer/object_resolver'
       require 'yoda/typing/inferencer/parameter_binder'
@@ -33,7 +33,8 @@ module Yoda
       # @param node [AST::Vnode]
       # @return [Store::Types::Base]
       def infer(node)
-        AstTraverser.new(tracer: tracer, context: context).traverse(node)
+        # AstTraverser.new(tracer: tracer, context: context).traverse(node)
+        Tree.build(node, context: context, tracer: tracer).type
       end
 
       # @param pp [PP]

data/lib/yoda/typing/node_info.rb

@@ -41,6 +41,11 @@ module Yoda
         tracer.constants(node)
       end
 
+      # @return [Array<String>]
+      def require_paths
+        tracer.require_paths(node)
+      end
+
       # @return [Types::Type]
       def type
         tracer.type(node)

data/lib/yoda/typing/tree/{defined.rb → ask_defined.rb}

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

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

@@ -1,44 +1,89 @@
+require 'forwardable'
+require 'pp'
+
 module Yoda
   module Typing
     module Tree
       # @abstract
       class Base
-        # @return [::AST::Node]
+        extend Forwardable
+
+        # @return [AST::Vnode]
         attr_reader :node
 
-        # @return [BaseContext]
+        # @return [Inferencer::Tracer]
+        attr_reader :tracer
+
+        # @return [Contexts::BaseContext]
         attr_reader :context
 
-        # @param node [::AST::Node]
-        # @param context [BaseContext]
+        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:, context:, parent: nil)
+        def initialize(node:, tracer:, context:, parent: nil)
           @node = node
+          @tracer = tracer
           @context = context
           @parent = parent
         end
 
-        # @abstract
-        # @return [Array<Base>]
-        def children
-          fail NotImplementedError
+        # @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
 
-        # @abstract
-        # @return [Types::Base]
-        def type
-          fail NotImplementedError
+        # @param node [AST::Vnode]
+        # @return [Base]
+        def build_child(node, context: self.context)
+          Tree.build(node, context: context, tracer: tracer, parent: self)
         end
 
-        # @return [Types::Generator]
-        def generator
-          @generator ||= Types::Generator.new(context.registry)
+        # @param node [AST::Vnode]
+        # @param (see #build_child)
+        # @return [Types::Type]
+        def infer_child(node, **kwargs)
+          build_child(node, **kwargs).type
         end
 
-        # @param node [::AST::Node]
-        # @return [Base]
-        def build_child(node, context: nil)
-          Tree.build(node, context: context, parent: self)
+        # @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

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

@@ -2,12 +2,12 @@ module Yoda
   module Typing
     module Tree
       class Begin < Base
-        def children
-          @children ||= node.children.map(&method(:build_child))
-        end
+        # @!method node
+        #   @return [AST::BlockNode]
 
-        def type
-          children.map(&:type).last
+        # @return [Types::Type]
+        def infer_type
+          node.children.map { |node| infer_child(node) }.last
         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

@@ -2,26 +2,15 @@ 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
+        # @!method node
+        #   @return [AST::CaseNode]
 
-        def else_branch
-          @else_branch ||= build_child(node.children.last)
+        # @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

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

@@ -1,29 +1,21 @@
+require 'yoda/typing/tree/namespace_inferable'
+
 module Yoda
   module Typing
     module Tree
       class ClassTree < Base
-        def type
-          infer_namespace_node(node)
-        end
+        include NamespaceInferable
 
-        # @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)
+        # @!method node
+        #   @return [AST::ClassNode]
 
-          if block_node
-            derive(context: block_context).infer(block_node)
+        # @return [Types::Base]
+        def infer_type
+          if super_class_node = node.super_class
+            infer_child(super_class_node)
           end
 
-          type
+          infer_namespace
         end
       end
     end