yoda-language-server 0.7.2 → 0.8.0

data/lib/yoda/model/{types → type_expressions}/value_type.rb

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class ValueType < Base
         attr_reader :value
 
@@ -48,6 +48,22 @@ module Yoda
           end
         end
 
+        # @param env [Environment]
+        def to_rbs_type(env)
+          case value_class
+          when '::TrueClass'
+            RBS::Types::Literal.new(literal: true, location: nil)
+          when '::FalseClass'
+            RBS::Types::Literal.new(literal: false, location: nil)
+          when '::NilClass'
+            RBS::Types::Bases::Nil.new(location: nil)
+          when '::Numeric'
+            RBS::Types::Literal.new(literal: value.to_i, location: nil)
+          else
+            RBS::Types::Literal.new(literal: value, location: nil)
+          end
+        end
+
         # @return [String]
         def to_s
           value

data/lib/yoda/model/type_expressions/void_type.rb

@@ -0,0 +1,37 @@
+module Yoda
+  module Model
+    module TypeExpressions
+      class VoidType < Base
+        def eql?(another)
+          false
+        end
+
+        def hash
+          [self.class.name].hash
+        end
+
+        # @param paths [Array<Paths>]
+        # @return [self]
+        def change_root(paths)
+          self
+        end
+
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          []
+        end
+
+        # @param env [Environment]
+        def to_rbs_type(env)
+          RBS::Types::Bases::Void.new(location: nil)
+        end
+
+        # @return [String]
+        def to_s
+          'void'
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/type_expressions.rb

@@ -0,0 +1,40 @@
+require 'parslet'
+require 'yoda/model/yard_type_parser'
+
+module Yoda
+  module Model
+    # Each type expression represents type annotations.
+    # Unlike type for symbolic execution, each type expression has {LexicalScope}
+    # and the corresponding constants are not determined yet.
+    module TypeExpressions
+      require 'yoda/model/type_expressions/base'
+      require 'yoda/model/type_expressions/any_type'
+      require 'yoda/model/type_expressions/value_type'
+      require 'yoda/model/type_expressions/instance_type'
+      require 'yoda/model/type_expressions/function_type'
+      require 'yoda/model/type_expressions/generator'
+      require 'yoda/model/type_expressions/duck_type'
+      require 'yoda/model/type_expressions/module_type'
+      require 'yoda/model/type_expressions/sequence_type'
+      require 'yoda/model/type_expressions/self_type'
+      require 'yoda/model/type_expressions/generic_type'
+      require 'yoda/model/type_expressions/union_type'
+      require 'yoda/model/type_expressions/unknown_type'
+      require 'yoda/model/type_expressions/void_type'
+
+      # @param string [String]
+      # @return [TypeExpressions::Base]
+      def self.parse(string)
+        Generator.new.apply(YardTypeParser.new.parse(string))
+      rescue Parslet::ParseFailed => failure
+        TypeExpressions::UnknownType.new(string)
+      end
+
+      # @param strings [Array<String>]
+      # @return [TypeExpressions::Base]
+      def self.parse_type_strings(strings)
+        TypeExpressions::UnionType.new(strings.map { |string| parse(string) })
+      end
+    end
+  end
+end

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

@@ -4,26 +4,41 @@ module Yoda
       # @abstract
       class Base
         # @abstract
-        # @return [Array<Functions::Base>]
-        def methods
+        # @return [Array<Store::Objects::Base>]
+        def referred_objects
           fail NotImplementedError
         end
 
         # @abstract
-        # @return [String]
-        def path
+        # @param name [String, Symbol]
+        # @return [Enumerator<FunctionSignatures::Wrapper>]
+        def select_method(name)
           fail NotImplementedError
         end
 
         # @abstract
-        # @return [String]
-        def docstring
+        # @param name [String, Symbol]
+        # @return [RBS::Types::t]
+        def select_constant_type(name)
           fail NotImplementedError
         end
 
         # @abstract
-        # @return [Array<[String, Integer]>]
-        def defined_files
+        # @param name [String, Symbol]
+        # @return [Array<Symbol>]
+        def select_constant_paths(name)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Base]
+        def singleton_class_value
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Base]
+        def instance_value
           fail NotImplementedError
         end
       end

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

@@ -0,0 +1,39 @@
+module Yoda
+  module Model
+    module Values
+      class EmptyValue < Base
+        # @param name [String, Symbol]
+        # @return [Array<Functions::Base>]
+        def select_method(name, **kwargs)
+          []
+        end
+
+        def referred_objects
+          []
+        end
+
+        # @param name [String, Symbol]
+        # @return [RBS::Types::t]
+        def 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)
+          []
+        end
+
+        # @return [EmptyValue]
+        def singleton_class_value
+          self
+        end
+
+        # @return [EmptyValue]
+        def instance_value
+          self
+        end
+      end
+    end
+  end
+end

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,23 @@
+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
+
+        # @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/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