yoda-language-server 0.7.1 → 0.9.0

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

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class ModuleType < Base
         # @return [ScopedPath]
         attr_reader :path
@@ -32,6 +32,12 @@ module Yoda
           [Store::Query::FindMetaClass.new(registry).find(path)].compact
         end
 
+        # @param env [Environment]
+        def to_rbs_type(env)
+          name = env.resolve_rbs_type_name(path)
+          name ? RBS::Types::Interface.new(name: name, args: [], location: nil) : RBS::Types::Bases::Any.new(location: nil)
+        end
+
         # @return [String]
         def to_s
           "#{path.path.to_s}.module"

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

@@ -0,0 +1,38 @@
+module Yoda
+  module Model
+    module TypeExpressions
+      class SelfType < Base
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(SelfType)
+        end
+
+        def hash
+          [self.class.name].hash
+        end
+
+        # @param paths [Array<Path>]
+        # @return [self]
+        def change_root(paths)
+          self
+        end
+
+        # @param registry [Registry]
+        # @return [Array<YARD::CodeObjects::Base>]
+        def resolve(registry)
+          fail NotImplementedError
+        end
+
+        # @return [String]
+        def to_s
+          'self'
+        end
+
+        # @param env [Environment]
+        def to_rbs_type(env)
+          RBS::Types::Bases::Self.new(location: nil)
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class SequenceType < Base
         attr_reader :base_type, :types
 
@@ -43,6 +43,11 @@ module Yoda
           "#{base_type}(#{types.map(&:to_s).join(', ')})"
         end
 
+        # @param env [Environment]
+        def to_rbs_type(env)
+          RBS::Types::Tuple.new(types: types.map { |t| t.to_rbs_type(env) }, location: nil)
+        end
+
         # @return [self]
         def map(&block)
           self.class.new(base_type.map(&block), types.map(&block))

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

@@ -2,7 +2,7 @@ require 'set'
 
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class UnionType < Base
         attr_reader :types
 
@@ -21,8 +21,7 @@ module Yoda
         end
 
         def eql?(another)
-          another.is_a?(UnionType) &&
-          Set.new(types) == Set.new(another.types)
+          another.is_a?(UnionType) && Set.new(types) == Set.new(another.types)
         end
 
         def hash
@@ -46,6 +45,11 @@ module Yoda
           types.map(&:to_s).join(' | ')
         end
 
+        # @param env [Environment]
+        def to_rbs_type(env)
+          RBS::Types::Union.new(types: types.map { |t| t.to_rbs_type(env) }, location: nil)
+        end
+
         # @return [self]
         def map(&block)
           self.class.new(types.map(&block))

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

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class UnknownType < Base
         attr_reader :name
 
@@ -34,6 +34,11 @@ module Yoda
         def to_s
           'any'
         end
+
+        # @param env [Environment]
+        def to_rbs_type(env)
+          RBS::Types::Bases::Any.new(location: nil)
+        end
       end
     end
   end

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