yoda-language-server 0.7.2 → 0.10.0

data/.travis.yml

@@ -1,8 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.4.1
-before_script: ./scripts/build_core_index.sh
-script:
-  - bundle exec ruby scripts/benchmark.rb
-  - bundle exec rake

data/client/vscode/src/test/index.ts

@@ -1,24 +0,0 @@
-//
-// PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING
-//
-// This file is providing the test runner to use when running extension tests.
-// By default the test runner in use is Mocha based.
-//
-// You can provide your own test runner if you want to override it by exporting
-// a function run(testRoot: string, clb: (error:Error) => void) that the extension
-// host can call to run the tests. The test runner is expected to use console.log
-// to report the results back to the caller. When the tests are finished, return
-// a possible error to the callback or null if none.
-
-import * as testRunner from 'vscode/lib/testrunner';
-
-// You can directly control Mocha options by uncommenting the following lines
-// See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
-testRunner.configure({
-    ui: 'bdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
-    useColors: true, // colored output from test results
-    timeout: 600000,
-
-});
-
-module.exports = testRunner;

data/lib/yoda/commands/setup.rb

@@ -1,51 +0,0 @@
-require 'ruby-progressbar'
-
-module Yoda
-  module Commands
-    class Setup < Base
-      # @return [String]
-      attr_reader :dir
-
-      # @return [true, false]
-      attr_reader :force_build
-
-      # @return [Hash{ Symbol => ProgressBar }]
-      attr_reader :bars
-
-      # @param dir [String]
-      def initialize(dir: nil, force_build: false)
-        @dir = dir || Dir.pwd
-        @force_build = force_build
-        @bars = {}
-      end
-
-      def run
-        build_core_index
-        if File.exist?(File.expand_path('Gemfile.lock', dir)) || force_build
-          Logger.info 'Building index for the current project...'
-          Instrument.instance.hear(initialization_progress: method(:on_progress), registry_dump: method(:on_progress)) do
-            force_build ? project.rebuild_cache : project.build_cache
-          end
-        else
-          Logger.info 'Skipped building project index because Gemfile.lock is not exist for the current dir'
-        end
-      end
-
-      def project
-        @project ||= Store::Project.new(dir)
-      end
-
-      private
-
-      def build_core_index
-        Store::Actions::BuildCoreIndex.run unless Store::Actions::BuildCoreIndex.exists?
-      end
-
-      def on_progress(phase: :save_keys, index: nil, length: nil, **params)
-        return unless index
-        bar = bars[phase] ||= ProgressBar.create(format: "%t: %c/%C |%w>%i| %e ", title: phase.to_s.gsub('_', ' '), starting_at: index, total: length)
-        bar.progress = index if index <= bar.total
-      end
-    end
-  end
-end

data/lib/yoda/commands.rb

@@ -1,69 +0,0 @@
-require 'thor'
-
-module Yoda
-  # Commands module has handler for each cli command.
-  module Commands
-    require 'yoda/commands/base'
-    require 'yoda/commands/file_cursor_parsable'
-    require 'yoda/commands/setup'
-    require 'yoda/commands/infer'
-    require 'yoda/commands/complete'
-
-    class Top < Thor
-      class_option :log_level, type: :string, desc: 'Set log level (debug info warn error fatal)'
-      class_option :profile, type: :boolean, desc: 'Set log level (debug info warn error fatal)'
-
-      desc 'setup', 'Setup indexes for current Ruby version and project gems'
-      option :force_build, type: :boolean, desc: "If enabled, (re)build current project's index forcibly"
-      def setup
-        process_class_options
-        Commands::Setup.run(force_build: options[:force_build])
-      end
-
-      desc 'infer POSITION', 'Infer the type of value at the specified position'
-      def infer(position)
-        process_class_options
-        Commands::Infer.run(position)
-      end
-
-      desc 'complete POSITION', 'Provide completion candidates for the specified position'
-      def complete(position)
-        process_class_options
-        Commands::Complete.run(position)
-      end
-
-      desc 'server', 'Start Language Server'
-      def server
-        process_class_options
-        Server.new.run
-      end
-
-      private
-
-      def process_class_options
-        set_log_level
-        use_profiler_if_enabled
-      end
-
-      def set_log_level
-        Yoda::Logger.log_level = options[:log_level].to_sym if options[:log_level]
-      end
-
-      def use_profiler_if_enabled
-        if options[:profile]
-          require 'stackprof'
-          require 'securerandom'
-          Logger.info('Enabled profiler')
-          StackProf.start(mode: :wall, raw: true)
-
-          at_exit do
-            StackProf.stop
-            tmpfile_path = File.expand_path(SecureRandom.hex(12), Dir.tmpdir)
-            StackProf.results(tmpfile_path)
-            Logger.fatal("Dumped file to: #{tmpfile_path}")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/yoda/evaluation/code_completion/base_provider.rb

@@ -1,57 +0,0 @@
-module Yoda
-  module Evaluation
-    class CodeCompletion
-      # @abstract
-      # Base class of completion candidates providers for code completion.
-      # This class bridges analysis features such as syntastic analysis {#analyzer} and symbolic execiton {#evaluator}.
-      class BaseProvider
-        # @return [Store::Registry]
-        attr_reader :registry
-
-        # @return [Parsing::SourceAnalyzer]
-        attr_reader :source_analyzer
-
-        # @param registry [Store::Registry]
-        # @param source_analyzer [Parsing::SourceAnalyzer]
-        def initialize(registry, source_analyzer)
-          @registry = registry
-          @source_analyzer = source_analyzer
-        end
-
-        # @abstract
-        # @return [true, false]
-        def providable?
-          fail NotImplementedError
-        end
-
-        # @abstract
-        # @return [Array<Model::CompletionItem>]
-        def candidates
-          fail NotImplementedError
-        end
-
-        private
-
-        # @return [SourceAnalyzer]
-        def analyzer
-          @analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
-        end
-
-        # @return [Evaluator]
-        def evaluator
-          @evaluator ||= Evaluator.from_ast(registry, source_analyzer.ast, location)
-        end
-
-        # @return [::Parser::AST::Node]
-        def ast
-          source_analyzer.ast
-        end
-
-        # @return [Parsing::Location]
-        def location
-          source_analyzer.location
-        end
-      end
-    end
-  end
-end

data/lib/yoda/evaluation/code_completion/variable_provider.rb

@@ -1,18 +0,0 @@
-module Yoda
-  module Evaluation
-    class CodeCompletion
-      # WIP
-      class VariableProvider < BaseProvider
-        # @return [true, false]
-        def providable?
-          false
-        end
-
-        # @return [Array<Model::CompletionItem>]
-        def candidates
-          []
-        end
-      end
-    end
-  end
-end

data/lib/yoda/evaluation/code_completion.rb

@@ -1,65 +0,0 @@
-module Yoda
-  module Evaluation
-    class CodeCompletion
-      require 'yoda/evaluation/code_completion/base_provider'
-      require 'yoda/evaluation/code_completion/method_provider'
-      require 'yoda/evaluation/code_completion/variable_provider'
-      require 'yoda/evaluation/code_completion/const_provider'
-
-      # @return [Store::Registry]
-      attr_reader :registry
-
-      # @return [String]
-      attr_reader :source
-
-      # @return [Parsing::Location]
-      attr_reader :location
-
-      # @param registry [Store::Registry]
-      # @param source   [String]
-      # @param location [Parsing::Location]
-      def initialize(registry, source, location)
-        @registry = registry
-        @source = source
-        @location = location
-      end
-
-      # @return [true, false]
-      def valid?
-        providers.any?(&:providable?)
-      end
-
-      # @return [Array<Model::CompletionItem>]
-      def candidates
-        providers.select(&:providable?).map(&:candidates).flatten
-      end
-
-      private
-
-      # @return [Array<CodeCompletion::BaseProvider>]
-      def providers
-        [method_provider, variable_provider, const_provider]
-      end
-
-      # @return [Parsing::SourceAnalyzer]
-      def source_analyzer
-        @source_analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
-      end
-
-      # @return [MethodProvider]
-      def method_provider
-        @method_provider ||= MethodProvider.new(registry, source_analyzer)
-      end
-
-      # @return [VariableProvider]
-      def variable_provider
-        @variable_provider ||= VariableProvider.new(registry, source_analyzer)
-      end
-
-      # @return [ConstantProvider]
-      def const_provider
-        @constant_provider ||= ConstProvider.new(registry, source_analyzer)
-      end
-    end
-  end
-end

data/lib/yoda/evaluation/current_node_explain.rb

@@ -1,71 +0,0 @@
-module Yoda
-  module Evaluation
-    # CurrentNodeExplain shows help for the current node.
-    class CurrentNodeExplain
-      # @return [Store::Registry]
-      attr_reader :registry
-
-      # @return [String]
-      attr_reader :source
-
-      # @return [Parsing::Location]
-      attr_reader :location
-
-      # @param registry [Store::Registry]
-      # @param source   [String]
-      # @param location [Parsing::Location]
-      def initialize(registry, source, location)
-        @registry = registry
-        @source = source
-        @location = location
-      end
-
-      # @return [Model::NodeSignature, nil]
-      def current_node_signature
-        return nil if !valid? || !current_node_trace
-        @current_node_signature ||= Model::NodeSignature.new(current_node, current_node_trace)
-      end
-
-      # @return [true, false]
-      def valid?
-        !!(current_node)
-      end
-
-      # @return [Array<(String, Integer, Integer)>]
-      def defined_files
-        return [] if !valid? || !current_node_trace
-        case current_node.type
-        when :send
-          current_node_trace.functions.map { |function| function.primary_source }.compact
-        when :const
-          current_node_trace.values.map { |value| value.primary_source || value.sources.first }.compact
-        else
-          []
-        end
-      end
-
-      private
-
-      # @return [Typing::Traces::Base, nil]
-      def current_node_trace
-        return nil unless valid?
-        @current_node_trace ||= evaluator.calculate_trace(current_node)
-      end
-
-      # @return [Parser::AST::Node]
-      def current_node
-        analyzer.nodes_to_current_location_from_root.last
-      end
-
-      # @return [Evaluator]
-      def evaluator
-        @evaluator ||= Evaluator.from_ast(registry, analyzer.ast, location)
-      end
-
-      # @return [SourceAnalyzer]
-      def analyzer
-        @analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
-      end
-    end
-  end
-end

data/lib/yoda/evaluation/evaluator.rb

@@ -1,105 +0,0 @@
-module Yoda
-  module Evaluation
-    class Evaluator
-      # @return [Parsing::Scopes::Base]
-      attr_reader :scope
-
-      # @return [Store::Registry]
-      attr_reader :registry
-
-      # @param registry [Store::Registry]
-      # @param ast [Parser::AST::Node]
-      # @param location [Parsing::Location]
-      # @return [Evaluator]
-      def self.from_ast(registry, ast, location)
-        from_root_scope(registry, Parsing::Scopes::Builder.new(ast).root_scope, location)
-      end
-
-      # @param registry [Store::Registry]
-      # @param root_scope [Parsing::Scopes::Root]
-      # @param location [Parsing::Location]
-      # @return [Evaluator]
-      def self.from_root_scope(registry, root_scope, location)
-        new(registry, root_scope.find_evaluation_root_scope(location) || root_scope)
-      end
-
-      # @param registry [Store::Registry]
-      # @param scope [Parsing::Scopes::Base]
-      def initialize(registry, scope)
-        @registry = registry
-        @scope = scope
-      end
-
-      # @param code_node   [::Parser::AST::Node]
-      # @return [Model::Types::Base, nil]
-      def calculate_type(code_node)
-        calculate_trace(code_node)&.type
-      end
-
-      # @param code_node   [::Parser::AST::Node]
-      # @return [Array<Store::Objects::Base>]
-      def calculate_values(code_node)
-        trace = calculate_trace(code_node)
-        trace ? trace.values : []
-      end
-
-      # @param code_node   [::Parser::AST::Node, nil]
-      # @return [Typing::Traces::Base, nil]
-      def calculate_trace(code_node)
-        return nil unless code_node
-        evaluate
-        evaluator.find_trace(code_node)
-      end
-
-      # @return [Store::Objects::Base, nil]
-      def scope_constant
-        @scope_constant ||= begin
-          Store::Query::FindConstant.new(registry).find(scope.scope_name)
-        end
-      end
-
-      private
-
-      def evaluate
-        unless @evaluated
-          evaluator.process(scope.body_node)
-          @evaluated = true
-        end
-      end
-
-      # @return [Typing::Evaluator]
-      def evaluator
-        @evaluator ||= Typing::Evaluator.new(evaluation_context)
-      end
-
-      # @return [Typing::Context]
-      def evaluation_context
-        @evaluation_context ||= begin
-          fail RuntimeError, "The namespace #{scope.scope_name} (#{scope}) is not registered" unless scope_constant
-          fail RuntimeError, "The namespace for #{scope} (#{scope.scope_name}) is not registered" unless receiver
-          lexical_scope = Typing::LexicalScope.new(scope_constant, scope.ancestor_scopes)
-          context = Typing::Context.new(registry: registry, caller_object: receiver, lexical_scope: lexical_scope)
-          context.env.bind_method_parameters(current_method_signature) if current_method_signature
-          context
-        end
-      end
-
-      # @return [Model::FunctionSignatures::Base, nil]
-      def current_method_signature
-        return unless scope.kind == :method
-        @current_method_signature ||= Store::Query::FindSignature.new(registry).select(scope_constant, scope.name.to_s)&.first
-      end
-
-      # @return [Store::Objects::Base, nil]
-      def receiver
-        @receiver ||= begin
-          if scope.kind == :method
-            Store::Query::FindConstant.new(registry).find(scope.scope_name)
-          else
-            Store::Query::FindMetaClass.new(registry).find(scope.scope_name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/yoda/evaluation/signature_discovery.rb

@@ -1,85 +0,0 @@
-module Yoda
-  module Evaluation
-    # SignatureDiscovery infers method candidates for the nearest send node and specify the number of index of these parameters.
-    # SignatureDiscovery shows help for the current parameter of method candidates.
-    class SignatureDiscovery
-      # @return [Store::Registry]
-      attr_reader :registry
-
-      # @return [String]
-      attr_reader :source
-
-      # @return [Parsing::Location]
-      attr_reader :location
-
-      # @param registry [Store::Registry]
-      # @param source   [String]
-      # @param location [Parsing::Location]
-      def initialize(registry, source, location)
-        @registry = registry
-        @source = source
-        @location = location
-      end
-
-      def valid?
-        !!nearest_send_node
-      end
-
-      # @return [Parsing::NodeObjects::SendNode, nil]
-      def nearest_send_node
-        @nearest_send_node ||= send_nodes_to_current_location.reverse.find { |node| node.on_parameter?(location) }
-      end
-
-      # @return [Array<Parsing::NodeObjects::SendNode>]
-      def send_nodes_to_current_location
-        @send_nodes_to_current_location ||= begin
-          analyzer.nodes_to_current_location_from_root.map do |node|
-            node.type == :send ? Parsing::NodeObjects::SendNode.new(node) : nil
-          end.compact
-        end
-      end
-
-      # @return [String, nil]
-      def index_word
-        nearest_send_node&.selector_name
-      end
-
-      # @return [Model::Types::Base]
-      def receiver_type
-        @receiver_type ||= begin
-          if nearest_send_node
-            evaluator.calculate_type(nearest_send_node.receiver_node)
-          else
-            Model::Types::InstanceType.new(analyzer.namespace_object.path)
-          end
-        end
-      end
-
-      # @return [Array<Store::Objects::MethodObject>]
-      def method_candidates
-        return [] unless valid?
-        receiver_values
-          .map { |value| Store::Query::FindSignature.new(registry).select(value, /\A#{Regexp.escape(index_word)}/) }
-          .flatten
-      end
-
-      private
-
-      # @return [Array<Store::Values::Base>]
-      def receiver_values
-        return [] unless valid?
-        @receiver_values ||= evaluator.calculate_values(nearest_send_node.receiver_node)
-      end
-
-      # @return [SourceAnalyzer]
-      def analyzer
-        @analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
-      end
-
-      # @return [Evaluator]
-      def evaluator
-        @evaluator ||= Evaluator.from_ast(registry, analyzer.ast, location)
-      end
-    end
-  end
-end

data/lib/yoda/evaluation.rb

@@ -1,9 +0,0 @@
-module Yoda
-  module Evaluation
-    require 'yoda/evaluation/evaluator'
-    require 'yoda/evaluation/current_node_explain'
-    require 'yoda/evaluation/comment_completion'
-    require 'yoda/evaluation/code_completion'
-    require 'yoda/evaluation/signature_discovery'
-  end
-end

data/lib/yoda/model/node_signature.rb

@@ -1,43 +0,0 @@
-module Yoda
-  module Model
-    class NodeSignature
-      # @return [::Parser::AST::Node]
-      attr_reader :node
-
-      # @return [Typing::Traces::Base]
-      attr_reader :trace
-
-      # @param node  [::Parser::AST::Node]
-      # @param trace [Typing::Traces::Base]
-      def initialize(node, trace)
-        @node = node
-        @trace = trace
-      end
-
-      # @return [Range]
-      def node_range
-        Parsing::Range.of_ast_location(node.location)
-      end
-
-      # @return [Array<Descriptions::Base>]
-      def descriptions
-        [top_description, *type_descriptions]
-      end
-
-      # @return [Descriptions::NodeDescription]
-      def top_description
-        Descriptions::NodeDescription.new(node, trace)
-      end
-
-      # @return [Array<Descriptions::Base>]
-      def type_descriptions
-        case trace
-        when Typing::Traces::Send
-          trace.functions.map { |function| Descriptions::FunctionDescription.new(function) }.take(1)
-        else
-          trace.values.map { |value| Descriptions::ValueDescription.new(value) }
-        end
-      end
-    end
-  end
-end