yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/model/primary_source_inferencer.rb

@@ -0,0 +1,34 @@
+module Yoda
+  module Model
+    class PrimarySourceInferencer
+      def initialize
+      end
+
+      # @param object [Yoda::Store::Objects::Base]
+      def infer_for_object(object)
+        object.primary_source || infer_primary_source_from_object_sources(object)
+      end
+
+      private
+
+      # @param object [Yoda::Store::Objects::Base]
+      def infer_primary_source_from_object_sources(object)
+        source_with_object_name =
+          object.sources.find do |(source_file, _row, _column)|
+            basename = File.basename(source_file, ".*")
+            object.name == to_constant_name(basename)
+          end
+
+        return source_with_object_name if source_with_object_name
+
+        object.sources.first
+      end
+
+      def to_constant_name(str)
+        str = str.to_s.split("/").last
+        # camelize
+        str.sub(/^[a-z]*/) { |match| match.capitalize }.gsub(/(?:_)([a-z]*)/i) { $1.capitalize }
+      end
+    end
+  end
+end

data/lib/yoda/model/scoped_path.rb

@@ -3,8 +3,9 @@ module Yoda
     # ScopedPath represents a path name written in namespaces.
     # ScopedPath owns lexical scopes where the path is written.
     class ScopedPath
-      # @return [Array<Path>] represents namespaces in order of nearness.
+      # @return [LexicalContext] represents namespaces in order of nearness.
       attr_reader :scopes
+      alias lexical_context scopes
 
       # @return [Path]
       attr_reader :path
@@ -18,7 +19,7 @@ module Yoda
       # @param scopes [Array<Path>] represents namespaces in order of nearness.
       # @param path [Path]
       def initialize(scopes, path)
-        @scopes = scopes.map { |pa| Path.build(pa) }
+        @scopes = LexicalContext.build(scopes)
         @path = Path.build(path)
       end
 
@@ -39,6 +40,16 @@ module Yoda
       def eql?(another)
         another.is_a?(ScopedPath) && path == another.path && scopes == another.scopes
       end
+
+      # @return [Array<Path>]
+      def absolute_paths
+        scopes.map { |scope| Path.from_names([scope, path]).absolute! }
+      end
+
+      # @return [Array<Path>]
+      def paths
+        scopes.map { |scope| Path.from_names([scope, path]) }
+      end
     end
   end
 end

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

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class AnyType < Base
         def eql?(another)
           another.is_a?(AnyType)
@@ -10,7 +10,7 @@ module Yoda
           [self.class.name].hash
         end
 
-        # @param paths [Array<Paths>]
+        # @param paths [LexicalContext]
         # @return [self]
         def change_root(paths)
           self
@@ -22,9 +22,13 @@ module Yoda
           []
         end
 
+        def to_rbs_type(_env)
+          RBS::Types::Bases::Any.new(location: nil)
+        end
+
         # @return [String]
         def to_s
-          'any'
+          'untyped'
         end
       end
     end

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

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       # @abstract
       class Base
         def ==(another)
@@ -8,9 +8,9 @@ module Yoda
         end
 
         # @abstract
-        # @param paths [Array<Path>]
+        # @param new_lexical_context [LexicalContext]
         # @return [Base]
-        def change_root(paths)
+        def change_root(new_lexical_context)
           fail NotImplementedError
         end
 
@@ -27,6 +27,13 @@ module Yoda
           fail NotImplementedError
         end
 
+        # @abstract
+        # @param env [Environment]
+        # @return [RBS::Types::Bases::Base, RBS::Types::Variable, RBS::Types::ClassSingleton, RBS::Types::Interface, RBS::Types::ClassInstance, RBS::Types::Alias, RBS::Types::Tuple, RBS::Types::Record, RBS::Types::Optional, RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Function, RBS::Types::Block, RBS::Types::Proc, RBS::Types::Literal]
+        def to_rbs_type(env)
+          fail NotImplementedError
+        end
+
         # @return [Base]
         def map
           yield self

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

@@ -1,6 +1,6 @@
 module Yoda
   module Model
-    module Types
+    module TypeExpressions
       class DuckType < Base
         attr_reader :method_name
 
@@ -19,7 +19,7 @@ module Yoda
           [self.class.name, method_name].hash
         end
 
-        # @param paths [Array<Paths>]
+        # @param paths [LexicalContext]
         # @return [self]
         def change_root(paths)
           self
@@ -31,6 +31,12 @@ module Yoda
           []
         end
 
+        # @param env [Environment]
+        def to_rbs_type(env)
+          # TODO: Implement as interface type
+          RBS::Types::Bases::Any.new(location: nil)
+        end
+
         # @return [String]
         def to_s
           "##{method_name}"

data/lib/yoda/model/type_expressions/function_type/parameter.rb

@@ -0,0 +1,95 @@
+module Yoda
+  module Model
+    module TypeExpressions
+      class FunctionType
+        class Parameter
+          # @return [String, nil]
+          attr_reader :name
+
+          # @return [Base]
+          attr_reader :type
+
+          # @param name [String, nil]
+          # @param type [Base]
+          def initialize(name: nil, type:)
+            @name = name
+            @type = type
+          end
+
+          # @param env [Environment]
+          # @return [RBS::Types::Function::Param]
+          def to_rbs_param(env)
+            RBS::Types::Function::Param.new(type: type.to_rbs_type(env), name: name.to_sym)
+          end
+
+          def map_type(&block)
+            self.class.new(name: name, type: block.call(type))
+          end
+
+          def ==(another)
+            eql?(another)
+          end
+
+          def eql?(another)
+            another.is_a?(Parameter) && name == another.name && type == another.type
+          end
+
+          def hash
+            [self.class.name, name, type].hash
+          end
+
+          # @return [String]
+          def keyword_expression(optional: false)
+            prefix = optional ? "?" : ""
+            "#{prefix}#{name}: #{type}"
+          end
+
+          # @return [String]
+          def optional_keyword_expression
+            keyword_expression(optional: true)
+          end
+
+          # @return [String]
+          def keyword_rest_expression
+            "**#{type} #{name}"
+          end
+
+          # @return [String]
+          def optional_expression
+            positional_expression(optional: true)
+          end
+
+          # @return [String]
+          def rest_expression
+            positional_expression(rest: true)
+          end
+
+          # @return [String]
+          def block_expression
+            positional_expression(block: true)
+          end
+
+          # @return [String]
+          def positional_expression(optioanl: false, rest: false, block: false)
+            prefix = begin
+              if optional
+                "?" 
+              elsif rest
+                "*"
+              elsif block
+                "&"
+              else
+                ""
+              end
+            end
+            if name
+              "#{prefix}#{type} #{name}"
+            else
+              "#{prefix}#{type}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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