yoda-language-server 0.7.1 → 0.9.0

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

@@ -1,78 +0,0 @@
-require 'fileutils'
-require 'bundler'
-require 'tmpdir'
-require 'digest'
-
-module Yoda
-  module Store
-    class Project
-      # Find registry file for the current project settings.
-      class Cache
-        class << self
-          # @param project_dir [String]
-          # @return [String]
-          def cache_dir(project_dir)
-            File.expand_path('.yoda/cache', project_dir)
-          end
-
-          # @param project_dir [String]
-          # @return [String]
-          def gemfile_lock_path(project_dir)
-            File.absolute_path('Gemfile.lock', project_dir)
-          end
-
-          # @param project [Project]
-          def build_for(project)
-            new(cache_dir_path: cache_dir(project.root_path), gemfile_lock_path: gemfile_lock_path(project.root_path))
-          end
-        end
-
-        # @return [String]
-        attr_reader :cache_dir_path
-
-        # @return [String, nil]
-        attr_reader :gemfile_lock_path
-
-        # @param cache_dir_path [String]
-        # @param gemfile_lock_path [String, nil]
-        def initialize(cache_dir_path:, gemfile_lock_path: nil)
-          @cache_dir_path = cache_dir_path
-          @gemfile_lock_path = gemfile_lock_path
-        end
-
-        # @return [true, false]
-        def present?
-          File.exist?(cache_path)
-        end
-
-        # @return [Registry]
-        def prepare_registry
-          make_cache_dir
-          Registry.new(Adapters.default_adapter_class.for(cache_path))
-        end
-
-        # @return [String]
-        def cache_path
-          File.expand_path(cache_name, cache_dir_path)
-        end
-
-        private
-
-        # @return [String]
-        def cache_name
-          @cache_path ||= begin
-            digest = Digest::SHA256.new
-            digest.file(gemfile_lock_path) if gemfile_lock_path && File.exist?(gemfile_lock_path)
-            digest.update(Registry::REGISTRY_VERSION.to_s)
-            digest.update(Adapters.default_adapter_class.type.to_s)
-            digest.hexdigest
-          end
-        end
-
-        def make_cache_dir
-          File.exist?(cache_dir_path) || FileUtils.mkdir_p(cache_dir_path)
-        end
-      end
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-module Yoda
-  module Store
-    class Project
-      class LibraryDocLoader
-        # @return [Registry]
-        attr_reader :registry
-
-        # @param gem_specs [Array<Objects::ProjectStatus::GemStatus, Bundler::LazySpecification>]
-        attr_reader :gem_specs
-
-        # @param errors [Array<BaseError>]
-        attr_reader :errors
-
-        class << self
-          # @param project [Project]
-          # @return [LibraryDocLoader]
-          def build_for(project)
-            new(registry: project.registry, gem_specs: gem_specs(project))
-          end
-
-          private
-
-          # @return [Bundler::LockfileParser, nil]
-          def parse_gemfile_lock(root_path, gemfile_lock_path)
-            return if !gemfile_lock_path || !File.exists?(gemfile_lock_path)
-            Dir.chdir(root_path) do
-              Bundler::LockfileParser.new(File.read(gemfile_lock_path))
-            end
-          end
-
-          def gem_specs(project)
-            lockfile_parser = parse_gemfile_lock(project.root_path, Cache.gemfile_lock_path(project.root_path))
-            (lockfile_parser&.specs || []).reject do |spec|
-              spec.source.is_a?(Bundler::Source::Path) && (File.expand_path(spec.source.path) == File.expand_path(project.root_path))
-            end
-          end
-        end
-
-        # @param registry [Registry]
-        # @param gem_specs [Array<Objects::ProjectStatus::GemStatus, Bundler::LazySpecification>]
-        def initialize(registry:, gem_specs:)
-          @registry = registry
-          @gem_specs = gem_specs
-          @errors = []
-        end
-
-        def run
-          project_status = registry.project_status || Objects::ProjectStatus.initial_build(specs: gem_specs)
-          new_bundle_status = update_bundle(project_status.bundle)
-          registry.save_project_status(project_status.derive(bundle: new_bundle_status))
-        end
-
-        private
-
-        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
-        # @return [Objects::ProjectStatus::BundleStatus]
-        def update_bundle(bundle_status)
-          unless bundle_status.all_present?
-            Logger.info 'Constructing database for the current project.'
-            bundle_status = import_deps(bundle_status)
-            Instrument.instance.initialization_progress(phase: :save, message: 'Saving registry')
-            registry.compress_and_save
-          end
-          bundle_status
-        end
-
-        # Try to import missing gems and core libraries.
-        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
-        # @return [Objects::ProjectStatus::BundleStatus]
-        def import_deps(bundle_status)
-          Instrument.instance.initialization_progress(phase: :load_core, message: 'Loading core index')
-          bundle_status = import_core(bundle_status) unless bundle_status.std_status.core_present?
-          bundle_status = import_std(bundle_status) unless bundle_status.std_status.std_present?
-          import_gems(bundle_status)
-        end
-
-        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
-        # @return [Objects::ProjectStatus::BundleStatus]
-        def import_core(bundle_status)
-          result = Actions::ImportCoreLibrary.run(registry)
-          errors.push(CoreImportError.new('core')) unless result
-          bundle_status.derive(std_status: bundle_status.std_status.derive(core_present: !!result))
-        end
-
-        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
-        # @return [Objects::ProjectStatus::BundleStatus]
-        def import_std(bundle_status)
-          result = Actions::ImportStdLibrary.run(registry)
-          errors.push(CoreImportError.new('std')) unless result
-          bundle_status.derive(std_status: bundle_status.std_status.derive(std_present: !!result))
-        end
-
-        # @param bundle_status [Objects::ProjectStatus::BundleStatus]
-        # @return [Objects::ProjectStatus::BundleStatus]
-        def import_gems(bundle_status)
-          present_gem_statuses, absent_gem_statuses = bundle_status.gem_statuses.partition { |gem_status| gem_status.present? }
-
-          progress = Instrument::Progress.new(absent_gem_statuses.length) do |index:, length:|
-            Instrument.instance.initialization_progress(phase: :load_gems, message: "Loading gems (#{index} / #{length})", index: index, length: length)
-          end
-
-          new_gem_statuses = absent_gem_statuses.map do |gem_status|
-            result = Actions::ImportGem.run(registry: registry, gem_name: gem_status.name, gem_version: gem_status.version)
-            progress.increment
-            errors.push(GemImportError.new(name: gem_status.name, version: gem_status.version)) unless result
-            gem_status.derive(present: result)
-          end
-
-          bundle_status.derive(gem_statuses: present_gem_statuses + new_gem_statuses)
-        end
-      end
-    end
-  end
-end

data/lib/yoda/typing/context.rb

@@ -1,96 +0,0 @@
-require 'set'
-
-module Yoda
-  module Typing
-    class Context
-      # @return [Store::Registry]
-      attr_reader :registry
-
-      # @return [Store::Objects::Base]
-      attr_reader :caller_object
-
-      # @return [LexicalScope]
-      attr_reader :lexical_scope
-
-      # @return [Environment]
-      attr_reader :env
-
-      # @return [TraceStore]
-      attr_reader :trace_store
-
-      # @param registry       [Store::Registry]
-      # @param caller_object  [Store::Objects::Base] represents who is the evaluator of the code.
-      # @param lexical_scope [Array<Path>] represents where the code presents.
-      def initialize(registry:, caller_object:, lexical_scope:, env: Environment.new, parent: nil, trace_store: TraceStore.new)
-        fail ArgumentError, registry unless registry.is_a?(Store::Registry)
-        fail ArgumentError, caller_object unless caller_object.is_a?(Store::Objects::Base)
-        fail ArgumentError, lexical_scope unless lexical_scope.is_a?(LexicalScope)
-
-        @registry = registry
-        @caller_object = caller_object
-        @lexical_scope = lexical_scope
-        @env = env
-        @trace_store = trace_store
-      end
-
-      # @param registry       [Store::Registry]
-      # @param caller_object  [Store::Objects::Base] represents who is the evaluator of the code.
-      # @param lexical_scope [Array<Path>] represents where the code presents.
-      # @return [self]
-      def derive(caller_object: self.caller_object, lexical_scope: self.lexical_scope)
-        self.class.new(registry: registry, caller_object: caller_object, lexical_scope: lexical_scope, parent: self, trace_store: trace_store)
-      end
-
-      # @param node  [::AST::Node]
-      # @return [Trace::Base, nil]
-      def find_trace(node)
-        trace_store.find_trace(node)
-      end
-
-      # @param node  [::AST::Node]
-      # @param trace [Trace::Base]
-      def bind_trace(node, trace)
-        trace_store.bind_trace(node, trace)
-      end
-
-      class TraceStore
-        def initialize
-          @traces = {}
-        end
-
-        # @param node  [::AST::Node]
-        # @return [Trace::Base, nil]
-        def find_trace(node)
-          @traces[node.is_a?(::Parser::AST::Node) ? ParserNodeWrapper.new(node) : node]
-        end
-
-        # @param node  [::AST::Node]
-        # @param trace [Trace::Base]
-        def bind_trace(node, trace)
-          @traces[node.is_a?(::Parser::AST::Node) ? ParserNodeWrapper.new(node) : node] = trace
-        end
-
-        class ParserNodeWrapper
-          # @return [::Parser::AST::Node]
-          attr_reader :node
-
-          # @param node [::Parser::AST::Node]
-          def initialize(node)
-            @node = node
-          end
-
-          # @param another [Object]
-          def eql?(another)
-            another.is_a?(ParserNodeWrapper) &&
-              node == another.node &&
-              node.location == another.node.location
-          end
-
-          def hash
-            [node, node.location].hash
-          end
-        end
-      end
-    end
-  end
-end

data/lib/yoda/typing/evaluator.rb

@@ -1,259 +0,0 @@
-module Yoda
-  module Typing
-    # Evaluator interpret codes abstractly and assumes types of terms.
-    class Evaluator
-      # @return [Context]
-      attr_reader :context
-
-      # @param context [Context]
-      def initialize(context)
-        @context = context
-      end
-
-      # @param node [::AST::Node]
-      # @return [Model::Types::Base]
-      def process(node)
-        evaluate(node).tap { |type| bind_trace(node, Traces::Normal.new(context, type)) unless find_trace(node) }
-      end
-
-      # @param node  [::AST::Node]
-      # @param trace [Trace::Base]
-      def bind_trace(node, trace)
-        context.bind_trace(node, trace)
-      end
-
-      # @param node  [::AST::Node]
-      # @return [Trace::Base, nil]
-      def find_trace(node)
-        context.find_trace(node)
-      end
-
-      private
-
-      # @param node [::AST::Node]
-      # @return [Model::Types::Base]
-      def evaluate(node)
-        case node.type
-        when :lvasgn, :ivasgn, :cvasgn, :gvasgn
-          evaluate_bind(node.children[0], process(node.children[1]))
-        when :casgn
-          # TODO
-          process(node.children.last)
-        when :masgn
-          # TODO
-          process(node.children.last)
-        when :op_asgn, :or_asgn, :and_asgn
-          # TODO
-          process(node.children.last)
-        when :and, :or, :not
-          # TODO
-          node.children.reduce(unknown_type) { |_type, node| process(node) }
-        when :if
-          evaluate_branch_nodes(node.children.slice(1..2).compact)
-        when :while, :until, :while_post, :until_post
-          # TODO
-          process(node.children[1])
-        when :for
-          # TODO
-          process(node.children[2])
-        when :case
-          evaluate_case_node(node)
-        when :super, :zsuper, :yield
-          # TODO
-          type_for_sexp_type(node.type)
-        when :return, :break, :next
-          # TODO
-          node.children[0] ? process(node.children[0]) : Model::Types::ValueType.new('nil')
-        when :resbody
-          # TODO
-          process(node.children[2])
-        when :csend, :send
-          evaluate_send_node(node)
-        when :block
-          evaluate_block_node(node)
-        when :const
-          const_node = Parsing::NodeObjects::ConstNode.new(node)
-          if const = context.lexical_scope.find_constant(context.registry, const_node.to_s)
-            Model::Types::ModuleType.new(const.path)
-          else
-            unknown_type
-          end
-        when :lvar, :cvar, :ivar, :gvar
-          env.resolve(node.children.first) || unknown_type
-        when :begin, :kwbegin, :block
-          node.children.reduce(unknown_type) { |_type, node| process(node) }
-        when :dstr, :dsym, :xstr
-          node.children.map { |node| process(node) }
-          type_for_sexp_type(node.type)
-        when :def
-          evaluate_method_definition(node)
-        when :defs
-          evaluate_smethod_definition(node)
-        when :hash
-          evaluate_hash_node(node)
-        else
-          type_for_sexp_type(node.type)
-        end
-      end
-
-      # @param node [Array<::AST::Node>]
-      # @return [Model::Types::Base]
-      def evaluate_branch_nodes(nodes)
-        Model::Types::UnionType.new(nodes.map { |node| process(node) })
-      end
-
-      # @param node [::AST::Node]
-      # @param env  [Environment]
-      # @return [Model::Types::Base]
-      def evaluate_send_node(node)
-        receiver_node, method_name_sym, *argument_nodes = node.children
-        if receiver_node
-          receiver_type = process(receiver_node)
-          receiver_candidates = receiver_type.resolve(context.registry)
-        else
-          receiver_type = type_of_class(context.caller_object)
-          receiver_candidates = [context.caller_object]
-        end
-
-        _type = argument_nodes.reduce([unknown_type]) { |(_type), node| process(node) }
-        method_candidates = receiver_candidates.map { |receiver| Store::Query::FindSignature.new(context.registry).select(receiver, method_name_sym.to_s) }.flatten
-        return_type = Model::Types::UnionType.new(method_candidates.map(&:type).map(&:return_type)).map do |type|
-          type.is_a?(Model::Types::ValueType) && type.value == 'self' ? receiver_type : type
-        end
-        trace = Traces::Send.new(context, method_candidates, return_type)
-        bind_trace(node, trace)
-        trace.type
-      end
-
-      # @param node [Array<::AST::Node>]
-      # @return [Model::Types::Base]
-      def evaluate_hash_node(node)
-        node.children.each do |node|
-          case node.type
-          when :pair
-            node.children.each(&method(:process))
-          when :kwsplat
-            node.children.each(&method(:process))
-          end
-        end
-        Model::Types::InstanceType.new('::Hash')
-      end
-
-      # @param node [::AST::Node]
-      # @param env  [Environment]
-      # @return [[Model::Types::Baseironment]]
-      def evaluate_block_node(node)
-        send_node, arguments_node, body_node = node.children
-        # TODO
-        _type = process(body_node)
-        process(send_node)
-      end
-
-      # @param node [::AST::Node]
-      # @param env  [Environment]
-      # @return [[Model::Types::Baseironment]]
-      def evaluate_case_node(node)
-        # TODO
-        subject_node, *when_nodes, else_node = node.children
-        _when_types = when_nodes.map { |node| node.children.last && process(node.children.last) }.compact
-        process(else_node)
-      end
-
-      # @param node [::AST::Node]
-      # @param type [Model::Types::Base]
-      # @param env  [Environment]
-      # @return [Model::Types::Base]
-      def evaluate_bind(symbol, type)
-        env.bind(symbol, type)
-        type
-      end
-
-      # @param sexp_type [::Symbol, nil]
-      def type_for_sexp_type(sexp_type)
-        case sexp_type
-        when :dstr, :str, :xstr, :string
-          Model::Types::InstanceType.new('::String')
-        when :dsym, :sym
-          Model::Types::InstanceType.new('::Symbol')
-        when :array, :splat
-          Model::Types::InstanceType.new('::Array')
-        when :irange, :erange
-          Model::Types::InstanceType.new('::Range')
-        when :regexp
-          Model::Types::InstanceType.new('::RegExp')
-        when :defined
-          boolean_type
-        when :self
-          type_of_class(context.caller_object)
-        when :true, :false, :nil
-          Model::Types::ValueType.new(sexp_type.to_s)
-        when :int, :float, :complex, :rational
-          Model::Types::InstanceType.new('::Numeric')
-        else
-          Model::Types::UnknownType.new(sexp_type)
-        end
-      end
-
-      # @param node [::AST::Node]
-      # @return [Model::Types::Base]
-      def evaluate_method_definition(node)
-        new_caller_object = context.lexical_scope.namespace
-        method_object = Store::Query::FindSignature.new(context.registry).select(new_caller_object, node.children[-3].to_s).first
-        new_context = context.derive(caller_object: new_caller_object)
-        new_context.env.bind_method_parameters(method_object) if method_object
-        method_body_node = node.children[-1]
-        method_body_node ? self.class.new(new_context).process(method_body_node) : nil_type
-      end
-
-      # @param node [::AST::Node]
-      # @return [Model::Types::Base]
-      def evaluate_smethod_definition(node)
-        type = process(node.children[-4])
-        new_caller_object = type.resolve(context.registry).first
-        method_object = Store::Query::FindSignature.new(context.registry).select(new_caller_object, node.children[-3].to_s).first
-        new_context = context.derive(caller_object: new_caller_object)
-        new_context.env.bind_method_parameters(method_object) if method_object
-        self.class.new(new_context).process(node.children[-1])
-      end
-
-      # @param object [Store::Objects::Base]
-      # @return [Model::Types::Base]
-      def type_of_class(object)
-        case object
-        when Store::Objects::ClassObject, Store::Objects::ModuleObject
-          Model::Types::InstanceType.new(object.path)
-        when Store::Objects::MetaClassObject
-          Model::Types::ModuleType.new(object.path)
-        else
-          Model::Types::UnknownType.new
-        end
-      end
-
-      def boolean_type
-        Model::Types::UnionType.new(Model::Types::ValueType.new('true'), Model::Types::ValueType.new('false'))
-      end
-
-      def unknown_type
-        Model::Types::UnknownType.new
-      end
-
-      def nil_type
-        Model::Types::ValueType.new('nil')
-      end
-
-      # @return [Environment]
-      def env
-        context.env
-      end
-
-      # @param node [Array<::AST::Node>]
-      # @param env  [Environment]
-      # @return [Array<Model::Values::Base>]
-      def process_to_instanciate(node)
-        type = evaluate(node)
-        bind_trace(node, Traces::Normal.new(context, type)) unless find_trace(node)
-        trace.values
-      end
-    end
-  end
-end

data/scripts/build_core_index.sh

@@ -1,16 +0,0 @@
-#!/bin/sh
-
-set -e
-
-BASE_DIR=$(cd $(dirname $(dirname $0)) && pwd)
-RUBY_VERSION=$(BUNDLE_GEMFILE=$BASE_DIR/Gemfile bundle exec ruby -e 'print RUBY_VERSION')
-
-mkdir -p ~/.yoda/sources/
-curl "https://cache.ruby-lang.org/pub/ruby/ruby-$RUBY_VERSION.tar.gz" > "/tmp/ruby-$RUBY_VERSION.tar.gz"
-tar xvzf "/tmp/ruby-$RUBY_VERSION.tar.gz" -C ~/.yoda/sources > /dev/null
-
-cd ~/.yoda/sources/ruby-$RUBY_VERSION
-BUNDLE_GEMFILE=$BASE_DIR/Gemfile bundle exec yardoc -n *.c
-BUNDLE_GEMFILE=$BASE_DIR/Gemfile bundle exec yardoc -b .yardoc-stdlib -o doc-stdlib -n
-
-echo "Complete to build YARD indexes of the core library and standard libraries."