yoda-language-server 0.7.2 → 0.10.0

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

@@ -1,20 +1,22 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class FunctionType < Base
+        require 'yoda/model/type_expressions/function_type/parameter'
+
         # @return [Base, nil]
         attr_reader :context
 
-        # @return [Array<Base>]
+        # @return [Array<Parameter>]
         attr_reader :required_parameters, :optional_parameters, :post_parameters
 
-        # @return [Array<(String, Base)>]
+        # @return [Array<Parameter>]
         attr_reader :required_keyword_parameters
 
-        # @return [Array<(String, Base)>]
+        # @return [Array<Parameter>]
         attr_reader :optional_keyword_parameters
 
-        # @return [Base, nil]
+        # @return [Parameter, nil]
         attr_reader :rest_parameter, :keyword_rest_parameter, :block_parameter
 
         # @return [Base]
@@ -25,11 +27,23 @@ module Yoda
         # @param optional_parameters [Array<Base>]
         # @param rest_parameter [Base, nil]
         # @param post_parameters [Array<Base>]
-        # @param keyword_parameters [Array<(String, Base)>]
+        # @param required_keyword_parameters [Array<(String, Base)>]
+        # @param optional_keyword_parameters [Array<(String, Base)>]
         # @param keyword_rest_parameter [Base, nil]
         # @param block_parameter [Base, nil]
         # @param return_type [Base]
         def initialize(context: nil, return_type:, required_parameters: [], optional_parameters: [], rest_parameter: nil, post_parameters: [], optional_keyword_parameters: [], required_keyword_parameters: [], keyword_rest_parameter: nil, block_parameter: nil)
+          fail TypeError, return_type unless return_type.is_a?(Base)
+          fail TypeError, context if context && !context.is_a?(Parameter)
+          fail TypeError, rest_parameter if rest_parameter && !rest_parameter.is_a?(Parameter)
+          fail TypeError, keyword_rest_parameter if keyword_rest_parameter && !keyword_rest_parameter.is_a?(Parameter)
+          fail TypeError, block_parameter if block_parameter && !block_parameter.is_a?(Parameter)
+          fail TypeError, required_parameters unless required_parameters.all? { |param| param.is_a?(Parameter) }
+          fail TypeError, optional_parameters unless optional_parameters.all? { |param| param.is_a?(Parameter) }
+          fail TypeError, post_parameters unless post_parameters.all? { |param| param.is_a?(Parameter) }
+          fail TypeError, optional_keyword_parameters unless optional_keyword_parameters.all? { |param| param.is_a?(Parameter) }
+          fail TypeError, required_keyword_parameters unless required_keyword_parameters.all? { |param| param.is_a?(Parameter) }
+
           @context = context
           @required_parameters = required_parameters
           @optional_parameters = optional_parameters
@@ -72,21 +86,10 @@ module Yoda
           ].hash
         end
 
-        # @param namespace [YARD::CodeObjects::Base]
-        # @return [UnionType]
+        # @param namespace [LexicalContext]
+        # @return [FunctionType]
         def change_root(namespace)
-          self.class.new(
-            context: context&.change_root(namespace),
-            return_type: return_type.change_root(namespace),
-            required_parameters: required_parameters.map { |param| param.change_root(namespace) },
-            optional_parameters: optional_parameters.map { |param| param.change_root(namespace) },
-            rest_parameter: rest_parameter&.change_root(namespace),
-            post_parameters: post_parameters.map { |param| param.change_root(namespace) },
-            required_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.change_root(namespace)] },
-            optional_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.change_root(namespace)] },
-            keyword_rest_parameter: keyword_rest_parameter&.change_root(namespace),
-            block_parameter: block_parameter&.change_root(namespace),
-          )
+          map { |type| type.change_root(namespace) }
         end
 
         # @param registry [Registry]
@@ -105,19 +108,40 @@ module Yoda
           (params_str.empty? ? '' : "(#{params_str}) -> ") + "#{return_type}"
         end
 
+        # @param env [Environment]
+        # @return [RBS::Types::Function]
+        def to_rbs_type(env)
+          make_param = -> (param) { param&.to_rbs_param(env) }
+          make_key_and_param = -> (param) { [param.name.to_sym, make_param.call(param)] }
+
+          RBS::Types::Function.new(
+            required_positionals: required_parameters.map(&make_param),
+            optional_positionals: optional_parameters.map(&make_param),
+            rest_positionals: make_param.call(rest_parameter),
+            trailing_positionals: post_parameters.map(&make_param),
+            # Not include keyword name to parameter object because if its string expression becomes redundunt.
+            required_keywords: required_keyword_parameters.map(&make_key_and_param).to_h,
+            optional_keywords: optional_keyword_parameters.map(&make_key_and_param).to_h,
+            rest_keywords: make_param.call(keyword_rest_parameter),
+            return_type: return_type&.to_rbs_type(env),
+          )
+        end
+
         # @return [self]
         def map(&block)
+          call_map_type = -> (param) { param&.map_type(&block) }
+
           self.class.new(
             context: context&.map(&block),
             return_type: return_type.map(&block),
-            required_parameters: required_parameters.map { |param| param.map(&block) },
-            optional_parameters: optional_parameters.map { |param| param.map(&block) },
-            rest_parameter: rest_parameter&.map(&block),
-            post_parameters: post_parameters.map { |param| param.map(&block) },
-            required_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.map(&block)] },
-            optional_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.map(&block)] },
-            keyword_rest_parameter: keyword_rest_parameter&.map(&block),
-            block_parameter: block_parameter&.map(&block),
+            required_parameters: required_parameters.map(&call_map_type),
+            optional_parameters: optional_parameters.map(&call_map_type),
+            rest_parameter: call_map_type.call(rest_parameter),
+            post_parameters: post_parameters.map(&call_map_type),
+            required_keyword_parameters: required_keyword_parameters.map(&call_map_type),
+            optional_keyword_parameters: required_keyword_parameters.map(&call_map_type),
+            keyword_rest_parameter: call_map_type.call(keyword_rest_parameter),
+            block_parameter: call_map_type.call(block_parameter),
           )
         end
 
@@ -125,48 +149,15 @@ module Yoda
 
         def all_parameters_to_s
           [
-            required_parameters_to_s,
-            optional_parameters_to_s,
-            rest_parameter_to_s,
-            post_parameters_to_s,
-            keyword_parameters_to_s,
-            keyword_rest_parameter_to_s,
-            block_parameter_to_s
-          ].reject { |str| str.empty? }.join(', ')
-        end
-
-        def required_parameters_to_s
-          required_parameters.map { |type| type.to_s }.join(', ')
-        end
-
-        def optional_parameters_to_s
-          optional_parameters.map { |type| "?#{type}" }.join(', ')
-        end
-
-        def required_keyword_parameters_to_s
-          return '' if required_keyword_parameters.empty?
-          required_keyword_parameters.map { |(name, type)| "#{name}: #{type}" }.join(', ')
-        end
-
-        def optional_keyword_parameters_to_s
-          return '' if optional_keyword_parameters.empty?
-          optional_keyword_parameters.map { |(name, type)| "?#{name}: #{type}" }.join(', ')
-        end
-
-        def post_parameters_to_s
-          post_parameters.map { |type| type.to_s }.join(', ')
-        end
-
-        def rest_parameter_to_s
-          rest_parameter ? "*#{rest_parameter}" : ''
-        end
-
-        def keyword_rest_parameter_to_s
-          keyword_rest_parameter ? "**#{keyword_rest_parameter}" : ''
-        end
-
-        def block_parameter_to_s
-          block_parameter ? "&#{block_parameter}" : ''
+            *required_parameters.map(&:positonal_expression),
+            *optional_parameters.map(&:optional_expression),
+            rest_parameter&.rest_expression,
+            *post_parameters.map(&:positional_expression),
+            *keyword_parameters.map(&:keyword_expression),
+            *optional_keyword_parameters.map(&:optional_keyword_expression),
+            keyword_rest_parameter&.keyword_rest_expression,
+            block_parameter&.block_expression,
+          ].compact.join(', ')
         end
       end
     end

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

@@ -0,0 +1,28 @@
+require 'parslet'
+
+module Yoda
+  module Model
+    module TypeExpressions
+      class Generator < Parslet::Transform
+        rule(instance_type: simple(:instance_type)) { TypeExpressions::InstanceType.new(instance_type.to_s) }
+        rule(value: simple(:value)) { TypeExpressions::ValueType.new(value.to_s) }
+        rule(value: 'self') { TypeExpressions::SelfType.new }
+        rule(value: 'void') { TypeExpressions::VoidType.new }
+
+        rule(base_type: simple(:base_type), key_type: simple(:key_type), value_type: simple(:value_type)) { TypeExpressions::GenericType.from_key_value(base_type, key_type, value_type) }
+        rule(base_type: simple(:base_type), value_types: sequence(:value_types)) { TypeExpressions::SequenceType.new(base_type, value_types) }
+        rule(base_type: simple(:base_type), value_types: simple(:value_type)) { TypeExpressions::SequenceType.new(base_type, [value_type]) }
+        rule(base_type: simple(:base_type), type_arguments: sequence(:type_arguments)) { TypeExpressions::GenericType.new(base_type, type_arguments) }
+
+        rule(method_name: simple(:method_name)) { TypeExpressions::DuckType.new(method_name) }
+        rule(key_type: simple(:key_type), value_type: simple(:value_type)) { TypeExpressions::GenericType.from_key_value(TypeExpressions::InstanceType.new('::Hash'), key_type, value_type) }
+        rule(value_types: sequence(:value_types)) { TypeExpressions::SequenceType.new(TypeExpressions::InstanceType.new('::Array'), value_types) }
+        rule(value_types: simple(:value_type)) { TypeExpressions::SequenceType.new(TypeExpressions::InstanceType.new('::Array'), [value_type]) }
+        rule(type_in_array: simple(:type)) { TypeExpressions::GenericType.new(TypeExpressions::InstanceType.new('::Array'), [type]) }
+
+        rule(types: sequence(:types)) { TypeExpressions::UnionType.new(types) }
+        rule(types: simple(:type)) { type }
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class GenericType < Base
         # @return [Base]
         attr_reader :base_type
@@ -21,7 +21,7 @@ module Yoda
           self.class.new(base_type.change_root(paths), type_arguments.map { |type| type.change_root(paths) })
         end
 
-        # @param base_type      [Types::Base]
+        # @param base_type      [TypeExpressions::Base]
         # @param type_arguments [Array<Base>]
         def initialize(base_type, type_arguments)
           @base_type = base_type
@@ -56,6 +56,21 @@ module Yoda
           "#{base_type}<#{type_arguments.map(&:to_s).join(', ')}>"
         end
 
+        # @param env [Environment]
+        def to_rbs_type(env)
+          type_args = type_arguments.map { |t| t.to_rbs_type(env) }
+          case base_type
+          when InstanceType
+            name = env.resolve_rbs_type_name(base_type.path)
+            name ? RBS::Types::ClassInstance.new(name: name, args: type_args, location: nil) : RBS::Types::Bases::Any.new(location: nil)
+          when ModuleType
+            name = env.resolve_rbs_type_name(base_type.path)
+            name ? RBS::Types::Interface.new(name: name, args: type_args, location: nil) : RBS::Types::Bases::Any.new(location: nil)
+          else
+            inner_type = base_type.to_rbs_type(env)
+          end
+        end
+
         # @return [self]
         def map(&block)
           self.class.new(base_type.map(&block), type_arguments.map(&block))

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

@@ -1,6 +1,8 @@
+require 'rbs'
+
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class InstanceType < Base
         # @return [ScopedPath]
         attr_reader :path
@@ -20,7 +22,7 @@ module Yoda
           [self.class.name, path].hash
         end
 
-        # @param paths [Array<Path>]
+        # @param paths [LexicalContext]
         # @return [self]
         def change_root(paths)
           self.class.new(path.change_scope(paths))
@@ -36,6 +38,12 @@ module Yoda
         def to_s
           path.path.to_s
         end
+
+        # @param env [Environment]
+        def to_rbs_type(env)
+          name = env.resolve_rbs_type_name(path)
+          name ? RBS::Types::ClassInstance.new(name: name, args: [], location: nil) : RBS::Types::Bases::Any.new(location: nil)
+        end
       end
     end
   end

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