yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/store/yard_importer.rb

@@ -9,6 +9,9 @@ module Yoda
       # @return [String, nil]
       attr_reader :root_path
 
+      # @return [String, nil]
+      attr_reader :source_path
+
       # @param file [String]
       # @param root_path [String, nil]
       # @return [Objects::Patch]
@@ -16,13 +19,20 @@ module Yoda
         store = YARD::RegistryStore.new
         store.load(file)
         root_path ||= File.expand_path('..', file)
-        new(file, root_path: root_path).import(store.values).patch
+        new(patch_id_for_file(file), root_path: root_path).import(store.values).patch
+      end
+
+      # @param file [String]
+      # @return [String]
+      def self.patch_id_for_file(file)
+        file
       end
 
       # @param id [String]
-      def initialize(id, root_path: nil)
+      def initialize(id, root_path: nil, source_path: nil)
         @patch = Objects::Patch.new(id)
         @root_path = root_path
+        @source_path = source_path
         @registered = Set.new
       end
 
@@ -39,7 +49,7 @@ module Yoda
       def register(code_object)
         return if @registered.member?(code_object.path)
         @registered.add(code_object.path)
-        register(code_object.parent) if code_object.parent && !code_object.parent.root?
+        register(code_object.parent) if code_object.parent
 
         new_objects = begin
           case code_object.type
@@ -64,7 +74,6 @@ module Yoda
           end
         end
 
-        register_to_parent_proxy(code_object) if code_object.parent && code_object.parent.type == :proxy
         [new_objects].flatten.compact.each { |new_object| patch.register(new_object) }
       end
 
@@ -79,7 +88,7 @@ module Yoda
           tag_list: code_object.tags.map { |tag| convert_tag(tag, '') },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: (code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path } + ['Object']).uniq,
         )
@@ -87,7 +96,7 @@ module Yoda
           path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
         )
         [object_class, object_meta_class]
@@ -149,7 +158,7 @@ module Yoda
           tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object)) },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path },
         )
@@ -158,7 +167,7 @@ module Yoda
           path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
         )
 
@@ -174,7 +183,7 @@ module Yoda
           tag_list: code_object.tags.map { |tag| convert_tag(tag, path_to_store(code_object)) },
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.instance_mixins.map { |mixin| path_to_store(mixin) },
           constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| path_to_store(constant) },
           superclass_path: !code_object.superclass || code_object.superclass&.path == 'Qnil' ? nil : path_to_store(code_object.superclass),
@@ -184,7 +193,7 @@ module Yoda
           path: path_to_store(code_object),
           sources: code_object.files.map(&method(:convert_source)),
           primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
-          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map { |meth| path_to_store(meth) },
           mixin_addresses: code_object.class_mixins.map { |mixin| path_to_store(mixin) },
         )
 
@@ -248,18 +257,11 @@ module Yoda
         [module_object, meta_class_object]
       end
 
-      # @param code_object [::YARD::CodeObjects::Base]
-      # @return [vaid]
-      def register_to_parent_proxy(code_object)
-        proxy_module = patch.find(path_to_store(code_object.parent))
-        proxy_module.instance_method_addresses.push(path_to_store(code_object)) if code_object.type == :method
-        proxy_module.constant_addresses.push(path_to_store(code_object)) if [:class, :module, :proxy].include?(code_object.type)
-      end
-
       # @param source [(String, Integer)]
       # @return [(String, Integer, Integer)]
       def convert_source(source)
         file, line = source
+        file = source_path if source_path && file == "(stdin)"
         [root_path ? File.expand_path(file, root_path) : file, line, 0]
       end
 
@@ -271,13 +273,13 @@ module Yoda
       end
 
       # @param code_object [::YARD::CodeObjects::Base]
-      # @return [String]
+      # @return [String] absolute object path to store.
       def calc_path_to_store(object)
         return 'Object' if object.root?
         parent_path = path_to_store(object.parent)
 
         if object.type == :proxy || object.is_a?(YARD::CodeObjects::Proxy)
-          # For now, we suppose the proxy object exists directly under its lexical namespace.
+          # For now, we suppose the proxy object exists directly under its namespace.
           [path_to_store(object.parent), object.name].join('::')
         elsif object.parent.path == path_to_store(object.parent)
           object.path

data/lib/yoda/store.rb

@@ -1,13 +1,27 @@
 require 'yard'
 
 module Yoda
+  # {Store} treats persistence and caching of code objects and querying of these objects in {Store::Registry}.
   module Store
     require 'yoda/store/actions'
     require 'yoda/store/adapters'
+    require 'yoda/store/config'
+    require 'yoda/store/file_tree'
     require 'yoda/store/project'
-    require 'yoda/store/registry'
     require 'yoda/store/objects'
+    require 'yoda/store/registry'
     require 'yoda/store/query'
+    require 'yoda/store/transformers'
+    require 'yoda/store/version_store'
     require 'yoda/store/yard_importer'
+
+    class << self
+      # @return [Project]
+      def setup(dir: Dir.pwd, force_build: false)
+        project = Project.for_path(dir)
+        project.setup(rebuild: force_build)
+        project
+      end
+    end
   end
 end

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

@@ -0,0 +1,14 @@
+require 'yoda/typing/constant_resolver/query'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      class CbaseQuery < Query
+        # @return [nil]
+        def parent
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'yoda/typing/constant_resolver/query'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      class MemberQuery < Query
+        # @return [Query]
+        attr_reader :parent
+
+        # @return [Symbol]
+        attr_reader :name
+
+        # @return [NodeTracer, nil]
+        attr_reader :tracer
+
+        # @param parent [Query]
+        # @param name [Symbol]
+        # @param tracer [NodeTracer, nil]
+        def initialize(parent:, name:, tracer: nil)
+          @parent = parent
+          @name = name
+          @tracer = tracer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Yoda
+  module Typing
+    class ConstantResolver
+      class NodeTracer
+        # @return [AST::Node]
+        attr_reader :node
+
+        # @return [Inferencer::Tracer]
+        attr_reader :tracer
+
+        # @param node [AST::Node]
+        # @param tracer [Inferencer::Tracer]
+        def initialize(node:, tracer:)
+          @node = node
+          @tracer = tracer
+        end
+
+        # @param type [Types::Base]
+        # @param context [Contexts::BaseContext]
+        def bind_type(type:, context:)
+          tracer.bind_type(node: node, type: type, context: context)
+        end
+
+        # @param context [Contexts::BaseContext]
+        def bind_context(context:)
+          tracer.bind_context(node: node, context: context)
+        end
+
+        # @param constants [Array<Store::Objects::Base>]
+        def bind_constants(constants:)
+          tracer.bind_constants(node: node, constants: constants)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Yoda
+  module Typing
+    class ConstantResolver
+      # @abstract
+      class Query
+        class << self
+          # @param node [AST::ConstantNode]
+          # @param tracer [Inferencer::Tracer]
+          def from_node(node, tracer: nil)
+            case node.type
+            when :cbase
+              CbaseQuery.new
+            when :empty
+              RelativeBaseQuery.new
+            else
+              MemberQuery.new(parent: from_node(node.base, tracer: tracer), name: node.name.name.to_s, tracer: tracer && NodeTracer.new(node: node, tracer: tracer))
+            end
+          end
+
+          def from_string(string, parent: RelativeBaseQuery.new)
+            base, child = string.split("::", 2)
+
+            case base
+            when nil
+              parent
+            when ""
+              base_query = CbaseQuery.new
+
+              if child.nil?
+                base_query
+              else
+                from_string(child, parent: base_query)
+              end
+            else
+              base_query = MemberQuery.new(parent: parent, name: base)
+
+              if child.nil?
+                base_query
+              else
+                from_string(child, parent: base_query)
+              end
+            end
+          end
+        end
+
+        # @abstract
+        # @return [Query, nil]
+        def parent
+          fail NotImplementedError
+        end
+
+        # @return [NodeTracer, nil]
+        def tracer
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'yoda/typing/constant_resolver/query'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      class RelativeBaseQuery < Query
+        # @return [nil]
+        def parent
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/constant_resolver.rb

@@ -0,0 +1,105 @@
+require 'forwardable'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      require 'yoda/typing/constant_resolver/cbase_query'
+      require 'yoda/typing/constant_resolver/member_query'
+      require 'yoda/typing/constant_resolver/node_tracer'
+      require 'yoda/typing/constant_resolver/query'
+      require 'yoda/typing/constant_resolver/relative_base_query'
+
+      extend Forwardable
+
+      # @return [Contexts::BaseContext]
+      attr_reader :context
+
+      # @return [Types::Generator]
+      delegate [:generator] => :context
+
+      # @param context [ContextsBaseContext]
+      def initialize(context:)
+        @context = context
+      end
+
+      # @param node [AST::ConstantNode]
+      # @param tracer [Inferncer::Tracer]
+      # @return [ConstantScope::Query]
+      def build_query_for_node(node, tracer:)
+        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)
+        query = Query.from_string(path.to_s)
+        resolve(query)
+      end
+
+      # @param query [ConstantScope::Query]
+      # @return [Types::Base]
+      def resolve(query)
+        query.tracer&.bind_context(context: context)
+        type = infer(query)
+        query.tracer&.bind_type(type: type, context: context)
+        type
+      end
+
+      private
+
+      def infer(query)
+        case query.parent
+        when CbaseQuery
+          # Remember constant candidates
+          constants = [context.environment.resolve_constant(query.name.to_s)].compact
+
+          query.tracer&.bind_constants(constants: constants)
+
+          generator.singleton_type_at("::#{query.name}")
+        when RelativeBaseQuery
+          lexical_values = context.lexical_scope_types.map(&:value)
+          relative_path = query.name.to_s
+
+          # Search nearest lexical scope first
+          found_paths = lexical_values.reverse.reduce(nil) do |found_paths, value|
+            found_paths || begin
+              current_found_paths = value.select_constant_paths(relative_path)
+              current_found_paths.empty? ? nil : current_found_paths
+            end
+          end
+
+          if found_paths
+            # Remember constant candidates
+            constants = [context.environment.resolve_constant(found_paths.first)].compact
+
+            query.tracer&.bind_constants(constants: constants)
+
+            generator.singleton_type_at(found_paths.first)
+          else
+            generator.any_type
+          end
+        when MemberQuery
+          base_type = resolve(query.parent)
+
+          # 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"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/base_context.rb

@@ -0,0 +1,83 @@
+require 'forwardable'
+require 'yoda/typing/contexts/context_derivation'
+
+module Yoda
+  module Typing
+    module Contexts
+      # @abstract
+      class BaseContext
+        extend Forwardable
+        include ContextDerivation
+
+        # @return [Model::Environment]
+        attr_reader :environment
+
+        # @return [Types::Type]
+        attr_reader :receiver
+
+        # @return [Types::Type]
+        attr_reader :constant_ref
+
+        # @return [BaseContext, nil]
+        attr_reader :parent
+
+        # @return [Inferencer::TypeBinding]
+        attr_reader :type_binding
+
+        delegate [:resolve_value_by_rbs_type]
+
+        # @param environment   [Model::Environment]
+        # @param receiver      [Types::Type] represents who is self of the code.
+        # @param constant_ref  [Types::Type] represents who is self of the code.
+        # @param parent        [BaseContext, nil]
+        # @param binds         [Hash{Symbol => RBS::Types::t}, nil]
+        def initialize(environment:, receiver:, constant_ref:, parent: nil, binds: nil)
+          @environment = environment
+          @receiver = receiver
+          @constant_ref = constant_ref
+          @parent = parent
+          @type_binding = Inferencer::TypeBinding.new(parent: parent_variable_scope_context&.type_binding, binds: binds)
+        end
+
+        # @deprecated Use methods of {BaseContext} instead.
+        def registry
+          environment.registry
+        end
+
+        def method_receiver
+          constant_ref.instance_type
+        end
+
+        # @abstract
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          fail NotImplementedError
+        end
+
+        # @return [Array<Types::Type>]
+        def lexical_scope_types
+          @lexical_scope_types ||= begin
+            parent_types = parent&.lexical_scope_types || []
+            if parent.nil?
+              [constant_ref]
+            elsif parent && constant_ref != parent.constant_ref
+              parent_types + [constant_ref]
+            else
+              parent_types
+            end
+          end
+        end
+
+        # @return [Types::Generator]
+        def generator
+          Types::Generator.new(environment: environment)
+        end
+
+        # @return [ConstantResolver]
+        def constant_resolver
+          ConstantResolver.new(context: self)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/block_context.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      class BlockContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          parent
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/context_derivation.rb

@@ -0,0 +1,59 @@
+module Yoda
+  module Typing
+    module Contexts
+      module ContextDerivation
+        # @abstract
+        # @return [Model::Environment]
+        def environment
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Types::Type]
+        def receiver
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Types::Type]
+        def constant_ref
+          fail NotImplementedError
+        end
+
+        # @param class_type [Types::Type]
+        def derive_class_context(class_type:)
+          NamespaceContext.new(
+            parent: self,
+            environment: environment,
+            receiver: class_type,
+            constant_ref: class_type,
+          )
+        end
+
+        # @param receiver_type [Types::Type]
+        # @param binds         [Hash{Symbol => Types::Type}, nil]
+        def derive_method_context(receiver_type:, binds:)
+          MethodContext.new(
+            parent: self,
+            environment: environment,
+            receiver: receiver_type,
+            constant_ref: constant_ref,
+            binds: binds,
+          )
+        end
+
+        # @param receiver_type [Types::Type]
+        # @param binds         [Hash{Symbol => Types::Type}, nil]
+        def derive_block_context(binds:, receiver_type: nil)
+          BlockContext.new(
+            parent: self,
+            environment: environment,
+            receiver: receiver_type || receiver,
+            constant_ref: constant_ref,
+            binds: binds,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/method_context.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      class MethodContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/namespace_block_context.rb

@@ -0,0 +1,29 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      # Block context which has its lexical scope (for instance_eval and instance_exec)
+      class NamespaceBlockContext < BaseContext
+        # @return [Store::Objects::NamespaceObject]
+        attr_reader :objects
+
+        # @param namespaces [Array<Store::Objects::NamespaceObject>] namespace objects which context resolution and method definition refer
+        def initialize(objects:, **kwargs)
+          @objects = objects
+          super(**kwargs)
+        end
+
+        # @return [Array<Store::Objects::NamespaceObject>]
+        def current_objects
+          objects
+        end
+
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          parent
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/namespace_context.rb

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+
+module Yoda
+  module Typing
+    module Contexts
+      class NamespaceContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts.rb

@@ -0,0 +1,25 @@
+module Yoda
+  module Typing
+    module Contexts
+      require 'yoda/typing/contexts/base_context'
+      require 'yoda/typing/contexts/block_context'
+      require 'yoda/typing/contexts/method_context'
+      require 'yoda/typing/contexts/namespace_block_context'
+      require 'yoda/typing/contexts/namespace_context'
+
+      # @return [NamespaceContext]
+      def self.root_scope(environment:)
+        generator = Types::Generator.new(environment: environment)
+
+        object_type = generator.instance_type_at("::Object")
+        object_class_type = generator.singleton_type_at("::Object")
+
+        NamespaceContext.new(
+          environment: environment,
+          receiver: object_type,
+          constant_ref: object_class_type,
+        )
+      end
+    end
+  end
+end

data/lib/yoda/typing/environment.rb

@@ -13,7 +13,7 @@ module Yoda
       end
 
       # @param key  [String, Symbol]
-      # @param type [Symbol, Model::Types::Base]
+      # @param type [Symbol, Model::TypeExpressions::Base]
       def bind(key, type)
         key = key.to_sym
         type = (type.is_a?(Symbol) && resolve(type)) || type