yoda-language-server 0.7.2 → 0.10.0

data/lib/yoda/model/values/instance_value.rb

@@ -1,63 +1,44 @@
+require 'forwardable'
+
 module Yoda
   module Model
     module Values
       class InstanceValue < Base
-        # @type Registry
-        attr_reader :registry
-
-        # @type ::YARD::CodeObjects::ClassObject | ::YARD::CodeObjects::Proxy
-        attr_reader :class_object
+        extend Forwardable
 
-        # @param registry [Registry]
-        # @param class_object [::YARD::CodeObjects::ClassObject, ::YARD::CodeObjects::Proxy]
-        def initialize(registry, class_object)
-          fail ArgumentError, registry unless registry.is_a?(Registry)
-          fail ArgumentError, class_object unless class_object.is_a?(::YARD::CodeObjects::NamespaceObject) || class_object.is_a?(::YARD::CodeObjects::Proxy)
-          @registry = registry
-          @class_object = class_object
-        end
+        # @return [Environment::AccessorInterface]
+        attr_reader :class_accessor
 
-        # @return [Array<Functions::Base>]
-        def methods(visibility: nil)
-          return [] if class_object.type == :proxy
-          opts = { scope: :instance, visibility: visibility }.compact
-          class_object.meths(opts).map { |meth| Functions::Method.new(meth) } + object_methods(visibility: visibility)
-        end
+        delegate [:select_constant_type, :select_constant_paths, :select_method] => :class_accessor_members
 
-        # @return [String]
-        def path
-          namespace.path
+        # @param class_accessor [Environment::AccessorInterface]
+        def initialize(class_accessor)
+          @class_accessor = class_accessor
         end
 
-        def namespace
-          class_object
+        def referred_objects
+          [class_accessor.class_object].compact
         end
 
-        # @param [String]
-        def docstring
-          class_object.docstring
+        # @return [InstanceValue]
+        def singleton_class_value
+          InstanceValue.new(class_accessor.singleton_accessor)
         end
 
-        # @return [Array<[String, Integer]>]
-        def defined_files
-          namespace.files
+        # @return [InstanceValue, EmptyValue]
+        def instance_value
+          if class_accessor.instance_accessor
+            InstanceValue.new(class_accessor.instance_accessor)
+          else
+            EmptyValue.new
+          end
         end
 
         private
 
-        # @return [Array<Functions::Base>]
-        def object_methods(visibility: nil)
-          return [] if class_object.type == :proxy
-          opts = { scope: :instance, visibility: visibility }.compact
-          method_names = Set.new(class_object.meths(opts).map(&:name))
-          if object = registry.find('::Object')
-            object.meths(opts)
-              .reject { |o| ![visibility].flatten.include?(:private) && o.namespace.name == :Kernel }
-              .reject { |o| method_names.include?(o.name) }
-              .map { |meth| Functions::Method.new(meth) }
-          else
-            []
-          end
+        # @return [Environment::NamespaceMembers]
+        def class_accessor_members
+          class_accessor.members
         end
       end
     end

data/lib/yoda/model/values/intersection_value.rb

@@ -0,0 +1,48 @@
+module Yoda
+  module Model
+    module Values
+      class IntersectionValue < Base
+        # @return [Environment::AccessorInterface]
+        attr_reader :values
+
+        # @param values [Array<Value>]
+        def initialize(*values)
+          @values = values
+        end
+
+        def referred_objects
+          values.flat_map(&:referred_objects)
+        end
+
+        # @param name [String, Symbol]
+        # @return [Array<FunctionSignatures::Base>]
+        def select_method(name, **kwargs)
+          values.flat_map { |value| select_method(name, **kwargs) }
+        end
+
+        # @param name [String, Symbol]
+        # @return [RBS::Types::t]
+        def select_constant_type(name, **kwargs)
+          types = values.flat_map { |value| select_constant_type(name, **kwargs) }
+          RBS::Types::Intersection.new(types: types, location: nil)
+        end
+
+        # @param name [String, Symbol]
+        # @return [Array<String>]
+        def select_constant_paths(name, **kwargs)
+          values.flat_map { |value| select_constant_type(name, **kwargs) }.uniq
+        end
+
+        # @return [UnionValue]
+        def singleton_class_value
+          IntersectionValue.new(*values.map(&:singleton_class_value))
+        end
+
+        # @return [UnionValue]
+        def instance_value
+          IntersectionValue.new(*values.map(&:instance_value))
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/values/literal_value.rb

@@ -0,0 +1,26 @@
+require 'forwardable'
+
+module Yoda
+  module Model
+    module Values
+      class LiteralValue
+        extend Forwardable
+
+        delegate [:referred_objects, :select_method, :select_constant_type, :select_constant_paths, :singleton_class_value, :instance_value] => :value
+
+        # @return [Base]
+        attr_reader :value
+
+        # @return [Object]
+        attr_reader :literal
+
+        # @param value [Base]
+        # @param literal [Object]
+        def initialize(value:, literal:)
+          @value = value
+          @literal = literal
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/values/union_value.rb

@@ -0,0 +1,50 @@
+module Yoda
+  module Model
+    module Values
+      class UnionValue < Base
+        # @return [Array<Values::Base>]
+        attr_reader :values
+
+        # @param values [Array<Values::Base>]
+        def initialize(*values)
+          @values = values
+        end
+
+        def referred_objects
+          values.flat_map(&:referred_objects)
+        end
+
+        # @param name [String, Symbol]
+        # @return [Array<FunctionSignatures::Wrapper>]
+        def select_method(name, **kwargs)
+          # Choose methods of shared ancestors
+          values.first&.select_method(name, **kwargs) || []
+        end
+
+        # @param name [String, Symbol]
+        # @return [RBS::Types::t]
+        def select_constant_type(name, **kwargs)
+          # Choose methods of shared ancestors
+          values.first&.select_constant_type(name, **kwargs) || RBS::Types::Bases::Any.new(location: nil)
+        end
+
+        # @param name [String, Symbol]
+        # @return [Array<String>]
+        def select_constant_paths(name, **kwargs)
+          # Choose methods of shared ancestors
+          values.first&.select_constant_paths(name, **kwargs) || []
+        end
+
+        # @return [IntersectionValue]
+        def singleton_class_value
+          UnionValue.new(*values.map(&:singleton_class_value))
+        end
+
+        # @return [IntersectionValue]
+        def instance_value
+          UnionValue.new(*values.map(&:instance_value))
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/values.rb

@@ -1,9 +1,13 @@
 module Yoda
   module Model
+    # Each Value represents the result for symbolic execution.
     module Values
       require 'yoda/model/values/base'
+      require 'yoda/model/values/empty_value'
       require 'yoda/model/values/instance_value'
-      require 'yoda/model/values/module_value'
+      require 'yoda/model/values/intersection_value'
+      require 'yoda/model/values/literal_value'
+      require 'yoda/model/values/union_value'
     end
   end
 end

data/lib/yoda/model/yard_type_parser.rb

@@ -0,0 +1,35 @@
+require 'parslet'
+
+module Yoda
+  module Model
+    class YardTypeParser < Parslet::Parser
+      rule(:method_name) { match('[a-z]') >> match('[a-zA-Z0-9_]').repeat }
+      rule(:duck_type) { str('#') >> method_name.as(:method_name) }
+      rule(:constant_name) { match('[A-Z]') >> match('[a-zA-Z0-9_]').repeat }
+      rule(:constant_full_name) { str('::').maybe >> (constant_name >> (str('::') | str('.'))).repeat >> constant_name }
+      rule(:value_name) { match('[a-z0-9]') >> match('[a-zA-Z0-9_]').repeat }
+
+      rule(:space) { match('\s').repeat(1) }
+      rule(:space?) { space.maybe }
+
+      rule(:constant_type) { value_name.as(:value) | constant_full_name.as(:instance_type) }
+
+      rule(:key_value_type) { constant_type.as(:base_type) >> str('{') >> space? >> type.as(:key_type) >> space? >> str('=>') >> space? >> type.as(:value_type) >> space? >> str('}') }
+      rule(:sequence_type) { constant_type.as(:base_type) >> str('(') >> space? >> types.as(:value_types) >> space? >> str(')') }
+      rule(:generic_type) { constant_type.as(:base_type) >> (str('<') >> space? >> type >> space? >> str('>')).repeat(1).as(:type_arguments) }
+
+      rule(:shorthand_key_value) { str('{') >> space? >> type.as(:key_type) >> space? >> str('=>') >> space? >> type.as(:value_type) >> space? >> str('}') }
+      rule(:shorthand_sequence) { str('(') >> space? >> types.as(:value_types) >> space? >> str(')') }
+      rule(:shorthand_array) { str('<') >> space? >> type.as(:type_in_array) >> space? >> str('>') }
+
+      rule(:union_type) { types.as(:types) }
+
+      rule(:single_type) { duck_type | shorthand_key_value | shorthand_array | shorthand_sequence | generic_type | key_value_type | sequence_type | constant_type }
+      rule(:types) { (single_type >> str(',') >> space?).repeat >> space? >> single_type }
+
+      rule(:type) { union_type }
+      rule(:base) { space? >> type >> space? }
+      root :base
+    end
+  end
+end

data/lib/yoda/model.rb

@@ -1,12 +1,17 @@
 module Yoda
   module Model
     require 'yoda/model/function_signatures'
+    require 'yoda/model/environment'
     require 'yoda/model/descriptions'
-    require 'yoda/model/node_signature'
+    require 'yoda/model/lexical_context'
+    require 'yoda/model/node_signatures'
     require 'yoda/model/path'
+    require 'yoda/model/primary_source_inferencer'
     require 'yoda/model/scoped_path'
-    require 'yoda/model/types'
+    require 'yoda/model/type_expressions'
     require 'yoda/model/values'
     require 'yoda/model/completion_item'
+    require 'yoda/model/parameters'
+    require 'yoda/model/yard_type_parser'
   end
 end

data/lib/yoda/parsing/comment_tokenizer.rb

@@ -3,14 +3,15 @@ require 'parslet'
 module Yoda
   module Parsing
     class CommentTokenizer
-      # @return [Sequence]
+      # @return [Array<Sequence, String>]
       def parse(str)
         Generator.new.apply(Tokenizer.new.parse(str))
       end
 
       class Tokenizer < Parslet::Parser
-        rule(:space) { match('\s').repeat(1) }
+        rule(:space) { match('[\s&&[^\n]]').repeat(1) }
         rule(:space?) { space.maybe }
+        rule(:newline) { match('\n') }
 
         rule(:comment_begin) { str('#') }
         rule(:tag) { str('@') >> (str('!').maybe >> match('[a-zA-Z0-9_-]').repeat) }
@@ -20,7 +21,10 @@ module Yoda
 
         rule(:comment_token) { sign | name }
 
-        rule(:base) { comment_begin.maybe >> space? >> tag.maybe.as(:tag) >> space? >> (comment_token.as(:token) >> space?).repeat.as(:tokens) }
+        rule(:tagline) { space? >> comment_begin.maybe >> space? >> tag.maybe.as(:tag) >> space? >> (comment_token.as(:token) >> space?).repeat.as(:tokens) }
+        rule(:textline) { space? >> comment_begin.maybe >> space? >> match('[^\n]*').as(:text) }
+        rule(:base) { (((tagline | textline) >> newline).repeat >> (tagline | textline).maybe).as(:lines) }
+
         root :base
       end
 
@@ -28,10 +32,13 @@ module Yoda
         rule(token: simple(:token)) { token }
         rule(tag: simple(:tag), tokens: sequence(:tokens)) { Sequence.new(tag: tag, tokens: tokens) }
         rule(tag: simple(:tag), tokens: simple(:token)) { Sequence.new(tag: tag, tokens: [token]) }
+        rule(text: simple(:text)) { Text.new(text) }
+        rule(lines: sequence(:lines)) { lines }
+        rule(lines: simple(:lines)) { [lines] }
       end
 
       class Sequence
-        # @type Parslet::Slice | nil
+        # @return [Parslet::Slice, nil]
         attr_reader :tag
 
         # @param tag [Parslet::Slice, nil]
@@ -54,6 +61,16 @@ module Yoda
           @tokens
         end
       end
+
+      class Text
+        # @return [Parslet::Slice]
+        attr_reader :content
+
+        # @param content [Parslet::Slice]
+        def initialize(content)
+          @content = content
+        end
+      end
     end
   end
 end

data/lib/yoda/parsing/location.rb

@@ -17,6 +17,15 @@ module Yoda
         @column = column
       end
 
+      def self.first_row
+        1
+      end
+
+      def self.first_column
+        0
+      end
+
+
       # @param ast_location [Parser::Source::Map, Parser::Source::Range]
       # @return [Location, nil]
       def self.of_ast_location(ast_location)

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

@@ -0,0 +1,85 @@
+module Yoda
+  module Parsing
+    module NodeObjects
+      class ArgsNode
+
+        # @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 == :args
+          @node = node
+        end
+
+        # @return [Model::Parameters::Multiple]
+        def parameter
+          Model::Parameters::Multiple.new(
+            parameters: parameter_nodes.map(&method(:parse_arg_node)),
+            rest_parameter: rest_parameter_node && parse_single_arg_node(rest_parameter_node),
+            post_parameters: post_parameter_nodes.map(&method(:parse_arg_node)),
+            keyword_parameters: keyword_parameter_nodes.map { |arg_node| Model::Parameters::Named.new(arg_node.children.first) },
+            keyword_rest_parameter: keyword_rest_parameter_node && parse_single_arg_node(keyword_rest_parameter_node),
+            block_parameter: block_parameter_node && parse_single_arg_node(block_parameter_node),
+          )
+        end
+
+        # @return [Array<::AST::Node>]
+        def parameter_nodes
+          @parameter_nodes ||= node.children.take_while { |arg_node| %i(arg optarg mlhs).include?(arg_node.type) }
+        end
+
+        # @return [::AST::Node, nil]
+        def rest_parameter_node
+          @rest_parameter_node ||= node.children.find { |arg_node| arg_node.type == :restarg }
+        end
+
+        # @return [Array<::AST::Node>]
+        def post_parameter_nodes
+          @post_parameter_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
+
+        # @return [Array<::AST::Node>]
+        def keyword_parameter_nodes
+          @keyword_parameter_nodes ||= node.children.select { |arg_node| %i(kwarg kwoptarg).include?(arg_node.type) }
+        end
+
+        # @return [::AST::Node, nil]
+        def keyword_rest_parameter_node
+          @keyword_rest_parameter_node ||= node.children.find { |arg_node| arg_node.type == :kwrestarg }
+        end
+
+        # @return [::AST::Node, nil]
+        def block_parameter_node
+          @block_parameter_node ||= node.children.find { |arg_node| arg_node.type == :blockarg }
+        end
+
+        private
+
+        # @param arg_node [::AST::Node]
+        # @return [Model::Parameters::Base]
+        def parse_arg_node(arg_node)
+          case arg_node.type
+          when :arg, :optarg
+            (name = arg_node.children.first) ? Model::Parameters::Named.new(name) : Model::Parameters::Unnamed.new
+          when :mlhs
+            mlhs_node = MlhsNode.new(arg_node)
+            rest_parameter = mlhs_node.rest_node && parse_single_arg_node(mlhs_node.rest_node)
+
+            Model::Parameters::Multiple.new(
+              parameters: mlhs_node.pre_nodes.map(&method(:parse_arg_node)),
+              rest_parameter: rest_parameter,
+              post_parameters: mlhs_node.post_nodes.map(&method(:parse_arg_node)),
+            )
+          end
+        end
+
+        # @param single_arg_node [::AST::Node]
+        # @return [Model::Parameters::Base]
+        def parse_single_arg_node(single_arg_node)
+          single_arg_node.children.first ? Model::Parameters::Named.new(single_arg_node.children.first) : Model::Parameters::Unnamed.new
+        end
+      end
+    end
+  end
+end

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

@@ -2,12 +2,12 @@ module Yoda
   module Parsing
     module NodeObjects
       class ConstNode
-        # @param node [::AST::Node]
+        # @param node [AST::Node]
         attr_reader :node
 
-        # @param node [::AST::Node]
+        # @param node [AST::Node]
         def initialize(node)
-          fail ArgumentError, node unless node.is_a?(::AST::Node) && node.type == :const
+          fail ArgumentError, node unless node.is_a?(AST::Node) && node.type == :const
           @node = node
         end
 

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)