yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/parsing/node_objects/mlhs_node.rb

@@ -0,0 +1,31 @@
+module Yoda
+  module Parsing
+    module NodeObjects
+      class MlhsNode
+        # @param node [::AST::Node]
+        attr_reader :node
+
+        # @param node [::AST::Node]
+        def initialize(node)
+          fail ArgumentError, node unless node.is_a?(::AST::Node) && node.type == :mlhs
+          @node = node
+        end
+
+        # @return [Array<::AST::Node>]
+        def pre_nodes
+          @pre_nodes ||= node.children.take_while { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }
+        end
+
+        # @return [::AST::Node, nil]
+        def rest_node
+          @rest_node ||= node.children.find { |arg_node| arg_node.type == :restarg }
+        end
+
+        # @return [Array<::AST::Node>]
+        def post_nodes
+          @post_nodes ||= node.children.drop_while { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }.select { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/node_objects.rb

@@ -5,6 +5,8 @@ module Yoda
       require 'yoda/parsing/node_objects/send_node'
       require 'yoda/parsing/node_objects/method_definition'
       require 'yoda/parsing/node_objects/namespace'
+      require 'yoda/parsing/node_objects/args_node'
+      require 'yoda/parsing/node_objects/mlhs_node'
     end
   end
 end

data/lib/yoda/parsing/parser.rb

@@ -4,24 +4,63 @@ module Yoda
   module Parsing
     class Parser
       # @param string [String]
-      # @return [::Parser::AST::Node]
+      # @return [AST::Vnode]
       def parse(string)
-        ::Parser::CurrentRuby.parse(string)
+        parse_with_comments(string).first
       end
 
       # @param string [String]
-      # @return [(::Parser::AST::Node, Array<::Parser::Source::Comment>)]
+      # @return [(AST::Vnode, Array<::Parser::Source::Comment>)]
       def parse_with_comments(string)
-        ::Parser::CurrentRuby.parse_with_comments(string)
+        source_buffer = create_source_buffer(source: string)
+        node, comments = parser.parse_with_comments(source_buffer)
+        comments_by_node = begin
+          if ::Parser::Source::Comment.respond_to?(:associate_by_identity)
+            ::Parser::Source::Comment.associate_by_identity(node, comments)
+          else
+            ::Parser::Source::Comment.associate(node, comments)
+          end
+        end
+        [AST.wrap(node, comments_by_node: comments_by_node), comments]
       end
 
       # @param string [String]
       # @return [(::Parser::AST::Node, Array<::Parser::Source::Comment>), nil]
       def parse_with_comments_if_valid(string)
-        parse_with_comments(source)
+        parse_with_comments(string)
       rescue ::Parser::SyntaxError
         nil
       end
+
+      # @param source [String]
+      # @param recover [Boolean].
+      # @return [Array] See {::Parser::Base.tokenize}
+      def tokenize(source, recover: false)
+        parser.tokenize(create_source_buffer(source: source), recover)
+      end
+
+      private
+
+      # @return [::Parser::Base]
+      def parser
+        # Don't use {::Parser::Base.default_parser} because the generated parser by the method reports errors to stdout.
+        @parser ||= ::Parser::CurrentRuby.new.tap do |parser|
+          parser.diagnostics.all_errors_are_fatal = true
+          parser.diagnostics.ignore_warnings = true
+        end
+      end
+
+      # @param source [String]
+      # @param filename [String, nil]
+      # @param line [Integer, nil]
+      # @return [::Parser::Source::Buffer]
+      def create_source_buffer(source:, filename: "(source)", line: 1)
+        source = source.dup.force_encoding(parser.default_encoding)
+
+        ::Parser::Source::Buffer.new(filename, line).tap do |buffer|
+          buffer.source = source
+        end
+      end
     end
   end
 end

data/lib/yoda/parsing/query/current_comment_token_query.rb

@@ -48,9 +48,10 @@ module Yoda
         # @return [CommentTokenizer::Sequence, nil]
         def tokenize
           return @tokenize if instance_variable_defined?(:@tokenized)
-          @tokenize = CommentTokenizer.new.parse(line_to_current_position)
-        rescue Parslet::ParseFailed
-          @tokenize = nil
+          @tokenize = begin
+            tokens = CommentTokenizer.new.parse(line_to_current_position)
+            tokens.first.is_a?(CommentTokenizer::Sequence) ? tokens.first : nil
+          end
         end
 
         # @return [String]

data/lib/yoda/parsing/query/current_commenting_node_query.rb

@@ -5,11 +5,11 @@ module Yoda
       class CurrentCommentingNodeQuery
         attr_reader :ast, :comments, :location
 
-        # @param ast      [::Parser::AST::Node]
+        # @param ast      [AST::Node]
         # @param comments [Array<::Parser::Source::Comment>]
         # @param location [Location] represents the current position.
         def initialize(ast, comments, location)
-          fail ArgumentError, ast unless ast.is_a?(::Parser::AST::Node)
+          fail ArgumentError, ast unless ast.is_a?(AST::Vnode)
           fail ArgumentError, comments unless comments.all? { |comment| comment.is_a?(::Parser::Source::Comment) }
           fail ArgumentError, location unless location.is_a?(Location)
           @ast = ast
@@ -35,20 +35,20 @@ module Yoda
         private
 
         def current_commenting_node_location
-          @current_commenting_node_location ||= Location.of_ast_location(current_commenting_node.location)
+          @current_commenting_node_location ||= current_commenting_node.location
         end
 
         # @return [Namespace]
         def namespace
-          @namespace ||= NodeObjects::Namespace.new(ast)
+          @namespace ||= ast.namespace
         end
 
-        # @return [{::Parser::AST::Node => Array<::Parser::Source::Comment>}]
+        # @return [{AST::Node => Array<::Parser::Source::Comment>}]
         def association
-          @association ||= ::Parser::Source::Comment.associate(ast, comments)
+          @association ||= ast.associate_comments(comments)
         end
 
-        # @return [{Array<::Parser::Source::Comment> => ::Parser::AST::Node}]
+        # @return [{Array<::Parser::Source::Comment> => AST::Node}]
         def inverse_association
           @inverse_association ||= association.invert
         end

data/lib/yoda/parsing/scopes/base.rb

@@ -19,7 +19,7 @@ module Yoda
         # @param node [::Parser::AST::Node]
         # @param parent [Base, nil]
         def initialize(node, parent = nil)
-          fail ArgumentError, node unless node.is_a?(::Parser::AST::Node)
+          fail ArgumentError, node unless node.is_a?(AST::Vnode)
           fail ArgumentError, parent if parent && !parent.is_a?(Base)
           @node = node
           @parent = parent

data/lib/yoda/parsing/scopes/builder.rb

@@ -24,7 +24,7 @@ module Yoda
         # @param scope [Base]
         # @return [void]
         def build(node, scope)
-          return if !node || !node.is_a?(AST::Node)
+          return if !node || !node.is_a?(AST::Vnode)
           case node.type
           when :def
             mscope = MethodDefinition.new(node, scope)

data/lib/yoda/parsing/source_cutter.rb

@@ -1,9 +1,13 @@
 module Yoda
   module Parsing
+    # SourceCutter modifies the given source to fix parse errors around the location.
     class SourceCutter
       class CannotRecoverError < StandardError; end
 
       attr_reader :source, :current_location
+
+      # @param source [String]
+      # @param current_location [Location]
       def initialize(source, current_location)
         @source = source
         @current_location = current_location
@@ -36,7 +40,7 @@ module Yoda
       # @return [Array<(Symbol, (String, ::Parser::Source::Range))>]
       def tokens_of_source
         @tokens_of_source ||= begin
-          _, _, tokens = ::Parser::CurrentRuby.new.tokenize(::Parser::Source::Buffer.new("(string)").tap { |b| b.source = source }, true)
+          _, _, tokens = Parser.new.tokenize(source, recover: true)
           tokens
         end
       end
@@ -103,7 +107,7 @@ module Yoda
         # @return [Symbol, nil]
         def diagnostic
           begin
-            ::Parser::CurrentRuby.parse(to_s)
+            Parsing::Parser.new.parse(to_s)
             nil
           rescue ::Parser::SyntaxError => ex
             fail CannotRecoverError, "Cannot recover: #{ex.diagnostic.render}" unless ex.diagnostic.reason == :unexpected_token

data/lib/yoda/parsing/traverser/matcher.rb

@@ -0,0 +1,65 @@
+module Yoda
+  module Parsing
+    class Traverser
+      class Matcher
+        # @return [Symbol, nil]
+        attr_reader :type
+
+        # @return [Symbol, nil]
+        attr_reader :name
+
+        # @return [Proc, nil]
+        attr_reader :predicate
+
+        # @param type [Symbol, nil]
+        # @param name [Symbol, nil]
+        def initialize(type: nil, name: nil, &predicate)
+          @type = type
+          @name = name
+          @predicate = predicate
+        end
+
+        # @param node [AST::Node]
+        # @return [Boolean]
+        def match?(node)
+          return false if type && type != node.type
+          return false if name && name != name_of(node)
+          return false if predicate && !predicate.call(node)
+          true
+        end
+
+        # @param node [AST::Node]
+        # @return [Symbol, nil]
+        # @see https://github.com/whitequark/parser/blob/v2.5.3.0/doc/AST_FORMAT.md
+        def name_of(node)
+          case node.type
+          when :lvar, :ivar, :cvar, :gvar
+            node.name
+          when :lvasgn, :ivasgn, :cvasgn, :gvasgn
+            node.assignee.try(:name)
+          when :const
+            node.name.name
+          when :casgn
+            node.assignee.name
+          when :sym
+            node.value
+          when :send, :csend
+            node.selector.name
+          when :"op-asgn"
+            node.children[1].name
+          when :def
+            node.name_clause.name
+          when :defs
+            node.name_clause.name
+          when :arg, :blockarg, :kwarg
+            node.content.try(:name)
+          when :optarg, :kwoptarg
+            node.content.try(:name)
+          when :restarg, :kwrestarg
+            node.content.try(:name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/traverser/query_interface.rb

@@ -0,0 +1,68 @@
+module Yoda
+  module Parsing
+    class Traverser
+      module QueryInterface
+        # @return [Traverser, nil]
+        def query(**kwargs, &predicate)
+          result = select(**kwargs, &predicate).first
+          result ? Traverser.new(result) : nil
+        end
+
+        # @return [ResultSet]
+        def query_all(**kwargs, &predicate)
+          ResultSet.new(select(**kwargs, &predicate))
+        end
+
+        # @return [Traverser, nil]
+        def query_ancestor(**kwargs, &predicate)
+          result = select_ancestors(**kwargs, &predicate).first
+          result ? Traverser.new(result) : nil
+        end
+
+        # @return [Traverser, nil]
+        def query_ancestors(**kwargs, &predicate)
+          ResultSet.new(select_ancestors(**kwargs, &predicate))
+        end
+
+        private
+
+        # @return [Enumerable<AST::Node>]
+        def select(**kwargs, &predicate)
+          matcher = Matcher.new(**kwargs, &predicate)
+          all_nodes.select { |node| matcher.match?(node) }
+        end
+
+        # @return [Enumerable<AST::Node>]
+        def select_ancestors(**kwargs, &predicate)
+          matcher = Matcher.new(**kwargs, &predicate)
+          nesting.select { |node| matcher.match?(node) }
+        end
+
+        # @param node [AST::Node]
+        # @return [Enumerable<AST::Node>]
+        def all_nodes_for(node)
+          Enumerator.new { |yielder| repeat_for(node, yielder) }.lazy
+        end
+
+        # @param node [AST::Node]
+        # @param yielder [Enumerator::Yielder]
+        def repeat_for(node, yielder)
+          yielder << node
+          node.children.select { |node| node.is_a?(AST::Node) }.each { |node| repeat_for(node, yielder) }
+        end
+
+        # @abstract
+        # @return [Enumerable<AST::Node>]
+        def all_nodes
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Enumerable<AST::Node>]
+        def nesting
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/traverser/result_set.rb

@@ -0,0 +1,37 @@
+require 'forwardable'
+
+module Yoda
+  module Parsing
+    class Traverser
+      class ResultSet
+        extend Forwardable
+        include QueryInterface
+        include Enumerable
+
+        # @return [Enumerable<AST::Node>]
+        attr_reader :nodes
+        delegate each: :nodes
+
+        # @params nodes [AST::Node]
+        def initialize(nodes)
+          @nodes = nodes
+        end
+
+        # @return [Enumerable<AST::Node>]
+        def all_nodes
+          flat_map(&method(:all_nodes_for))
+        end
+
+        # @return [Enumerable<AST::Node>]
+        def nesting
+          flat_map(&method(:nesting))
+        end
+
+        # @return [Array<AST::Node>]
+        def to_a
+          nodes.to_a
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/traverser.rb

@@ -0,0 +1,29 @@
+module Yoda
+  module Parsing
+    # Traverser searches {AST::Node} with the given queries.
+    class Traverser
+      require 'yoda/parsing/traverser/query_interface'
+      require 'yoda/parsing/traverser/matcher'
+      require 'yoda/parsing/traverser/result_set'
+      include QueryInterface
+
+      # @return [AST::Node]
+      attr_reader :node
+
+      # @param node [AST::Node]
+      def initialize(node)
+        @node = node
+      end
+
+      # @return [Enumerable<AST::Node>]
+      def all_nodes
+        all_nodes_for(node)
+      end
+
+      # @return [Enumerable<AST::Node>]
+      def nesting
+        node.nesting
+      end
+    end
+  end
+end

data/lib/yoda/parsing/type_parser.rb

@@ -3,12 +3,12 @@ require 'parslet'
 module Yoda
   module Parsing
     class TypeParser
-      # @return [Model::Types::Base]
+      # @return [Model::TypeExpressions::Base]
       def parse(str)
         Generator.new.apply(Parser.new.parse(str))
       end
 
-      # @return [Model::Types::Base, nil]
+      # @return [Model::TypeExpressions::Base, nil]
       def safe_parse(str)
         parse(str)
       rescue Parslet::ParseFailed => failure
@@ -80,20 +80,20 @@ module Yoda
         rule(params: sequence(:param_types), return_type: simple(:return_type)) { Generator.create_function_type(nil, param_types, return_type) }
         rule(params: simple(:param_type), return_type: simple(:return_type)) { Generator.create_function_type(nil, [param_type], return_type) }
 
-        rule(instance_type: simple(:class_name)) { Model::Types::InstanceType.new(class_name.to_s) }
-        rule(module_type: simple(:module_name)) { Model::Types::ModuleType.new(module_name.to_s) }
-        rule(value_type: simple(:value_name)) { Model::Types::ValueType.new(value_name.to_s) }
-        rule(any_type: simple(:any)) { Model::Types::AnyType.new }
+        rule(instance_type: simple(:class_name)) { Model::TypeExpressions::InstanceType.new(class_name.to_s) }
+        rule(module_type: simple(:module_name)) { Model::TypeExpressions::ModuleType.new(module_name.to_s) }
+        rule(value_type: simple(:value_name)) { Model::TypeExpressions::ValueType.new(value_name.to_s) }
+        rule(any_type: simple(:any)) { Model::TypeExpressions::AnyType.new }
 
-        rule(sequence_type: simple(:type)) { Model::Types::SequenceType.new(Model::Types::InstanceType.new('::Array'), [type]) }
-        rule(sequence_type: sequence(:types)) { Model::Types::SequenceType.new(Model::Types::InstanceType.new('::Array'), types) }
+        rule(sequence_type: simple(:type)) { Model::TypeExpressions::SequenceType.new(Model::TypeExpressions::InstanceType.new('::Array'), [type]) }
+        rule(sequence_type: sequence(:types)) { Model::TypeExpressions::SequenceType.new(Model::TypeExpressions::InstanceType.new('::Array'), types) }
 
         rule(generic_abs: simple(:generic_abs), generic_abs_body: simple(:type)) { type }
 
         rule(base_type: simple(:base_type)) { base_type }
-        rule(base_type: simple(:base_type), generic_type_params: simple(:type_param)) { Model::Types::GenericType.new(base_type, [type_param]) }
-        rule(base_type: simple(:base_type), generic_type_params: sequence(:type_params)) { Model::Types::GenericType.new(base_type, type_params) }
-        rule(union_type: sequence(:types)) { Model::Types::UnionType.new(types) }
+        rule(base_type: simple(:base_type), generic_type_params: simple(:type_param)) { Model::TypeExpressions::GenericType.new(base_type, [type_param]) }
+        rule(base_type: simple(:base_type), generic_type_params: sequence(:type_params)) { Model::TypeExpressions::GenericType.new(base_type, type_params) }
+        rule(union_type: sequence(:types)) { Model::TypeExpressions::UnionType.new(types) }
 
         def self.create_function_type(context, param_types, return_type)
           func_options = param_types.each_with_object({ context: context, return_type: return_type }).with_index do |(param, func_options), index|
@@ -101,30 +101,30 @@ module Yoda
             when :required
               if func_options[:rest_parameter]
                 func_options[:post_parameters] ||= []
-                func_options[:post_parameters].push(param.type)
+                func_options[:post_parameters].push(param.to_paramter)
               else
                 func_options[:required_parameters] ||= []
-                func_options[:required_parameters].push(param.type)
+                func_options[:required_parameters].push(param.to_paramter)
               end
             when :optional
               func_options[:optional_parameters] ||= []
-              func_options[:optional_parameters].push(param.type)
+              func_options[:optional_parameters].push(param.to_paramter)
             when :rest
-              func_options[:rest_parameter] = param.type
+              func_options[:rest_parameter] = param.to_paramter
             when :required_keyword
               func_options[:required_keyword_parameters] ||= []
-              func_options[:required_keyword_parameters].push(param.keyword, param.type)
+              func_options[:required_keyword_parameters].push(param.to_paramter)
             when :optional_keyword
               func_options[:optional_keyword_parameters] ||= []
-              func_options[:optional_keyword_parameters].push(param.keyword, param.type)
+              func_options[:optional_keyword_parameters].push(param.to_paramter)
             when :keyword_rest
-              func_options[:keyword_rest_parameter] = param.type
+              func_options[:keyword_rest_parameter] = param.to_paramter
             when :block
-              func_options[:block_parameter] = param.type
+              func_options[:block_parameter] = param.to_paramter
             end
           end
 
-          Model::Types::FunctionType.new(func_options)
+          Model::TypeExpressions::FunctionType.new(**func_options)
         end
 
         class Param
@@ -134,6 +134,10 @@ module Yoda
             @keyword = keyword
             @type = type
           end
+
+          def to_paramter
+            Model::TypeExpressions::FunctionType::Parameter.new(name: keyword, type: type)
+          end
         end
       end
     end

data/lib/yoda/parsing.rb

@@ -3,7 +3,6 @@ module Yoda
     require 'yoda/parsing/ast_traversable'
     require 'yoda/parsing/comment_tokenizer'
     require 'yoda/parsing/parser'
-    require 'yoda/parsing/source_analyzer'
     require 'yoda/parsing/node_objects'
     require 'yoda/parsing/location'
     require 'yoda/parsing/scopes'
@@ -11,5 +10,32 @@ module Yoda
     require 'yoda/parsing/range'
     require 'yoda/parsing/query'
     require 'yoda/parsing/type_parser'
+    require 'yoda/parsing/traverser'
+
+    class << self
+      # @see {Parser#parse}
+      def parse(*args)
+        Parser.new.parse(*args)
+      end
+
+      # @see {Parser#parse_with_comments}
+      def parse_with_comments(*args)
+        Parser.new.parse_with_comments(*args)
+      end
+
+      # @see {Parser#parse_with_comments_if_valid}
+      def parse_with_comments_if_valid(*args)
+        Parser.new.parse_with_comments_if_valid(*args)
+      end
+
+      # Fix parse errors of the given source and return the modified source.
+      # @param source [String]
+      # @param location [Location]
+      # @return [String] Modified source to fix parse errors.
+      # @raise [SourceCutter::CannotRecoverError]
+      def fix_parse_error(source:, location:)
+        SourceCutter.new(source, location).error_recovered_source
+      end
+    end
   end
 end

data/lib/yoda/presentation/code_completion/constant.rb

@@ -0,0 +1,27 @@
+module Yoda
+  module Constant
+    class Candidates
+      def initialize(constant_candidates:, range:, prefix:)
+        @constant_candidates = constant_candidates
+        @range = range
+        @prefix = prefix
+      end
+
+      # @param object [Store::Objects::Base]
+      # @return [Symbol]
+      def complete_item_kind(object)
+        case object.kind
+        when :class
+          :class
+        when :module
+          :module
+        else
+          :constant
+        end
+      end
+    end
+
+    class Candidate
+    end
+  end
+end