yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/typing/tree.rb

@@ -0,0 +1,96 @@
+module Yoda
+  module Typing
+    module Tree
+      require 'yoda/typing/inferencer/arguments_binder'
+      require 'yoda/typing/inferencer/contexts'
+      require 'yoda/typing/inferencer/environment'
+      require 'yoda/typing/inferencer/constant_resolver'
+      require 'yoda/typing/inferencer/method_resolver'
+      require 'yoda/typing/inferencer/method_definition_resolver'
+      require 'yoda/typing/inferencer/object_resolver'
+      require 'yoda/typing/inferencer/tracer'
+
+      class << self
+        # @param node [::AST::Node]
+        # @return [Base]
+        def build(node, **kwargs)
+          klass_for_node(node).new(node: node, **kwargs)
+        end
+
+        # @param node [::AST::Node]
+        # @return [class<Base>]
+        def klass_for_node(node)
+          case node.type
+          when :lvasgn, :ivasgn, :cvasgn, :gvasgn
+            VariableAssignment
+          when :casgn
+            ConstantAssignment
+          when :masgn
+            MultipleAssignment
+          when :op_asgn, :or_asgn, :and_asgn
+            LogicalAssignment
+          when :and, :or, :not
+            LogicalOperator
+          when :if
+            If
+          when :while, :until, :while_post, :until_post
+            While
+          when :for
+            For
+          when :case
+            Case
+          when :super, :zsuper
+            Super
+          when :yield
+            Yield
+          when :return, :break, :next
+            Escape
+          when :resbody
+            RescueBody
+          when :csend, :send
+            Send
+          when :block
+            Block
+          when :const
+            Const
+          when :lvar, :cvar, :ivar, :gvar
+            Variable
+          when :begin, :kwbegin
+            Begin
+          when :dstr, :dsym, :xstr
+            LiteralWithInterpolation
+          when :def
+            Method
+          when :defs
+            SingletonMethod
+          when :hash
+            HashBody
+          when :self
+            Self
+          when :defined
+            Defined
+          when :module
+            ModuleTree
+          when :class
+            ClassTree
+          else
+            Literal
+          end
+        end
+      end
+
+      private
+
+      # @return [Types::Generator]
+      def generator
+        @generator ||= Types::Generator.new(context.registry)
+      end
+
+      # @param context [Context]
+      # @return [self]
+      def derive(context:)
+        self.class.new(context: context, tracer: tracer)
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/any.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module Typing
+    module Types
+      class Any < Base
+        def to_expression
+          Model::TypeExpressions::AnyType.new
+        end
+
+        def to_type_string
+          "any"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/associative_array.rb

@@ -0,0 +1,28 @@
+module Yoda
+  module Typing
+    module Types
+      class AssociativeArray < Base
+        # @return [::Hash{ String, Symbol => Base }]
+        attr_reader :contents
+
+        # @param contents [::Hash{ String, Symbol => Base }]
+        def initialize(contents:)
+          @contents = contents
+        end
+
+        def to_expression
+          contents.transform_values(&:to_expression)
+        end
+
+        def visilibity
+          @self_call ? [:private, :public, :protected] : [:public]
+        end
+
+        def to_type_string
+          inner = contents.map { |key, value| "#{key} => #{value.to_type_string}"}
+          "{#{inner.join(', ')}}"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/base.rb

@@ -0,0 +1,25 @@
+module Yoda
+  module Typing
+    module Types
+      # @abstract
+      class Base
+        def reference?
+          false
+        end
+
+        # @abstract
+        # @param resolver [Resolver]
+        # @return [Store::TypeExpressions::Base]
+        def to_expression(resolver)
+          fail NotImplemetedError
+        end
+
+        # @abstract
+        # @return [String]
+        def to_type_string
+          fail NotImplemetedError
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/converter.rb

@@ -0,0 +1,67 @@
+module Yoda
+  module Typing
+    module Types
+      class Converter
+        # @return [Generator]
+        attr_reader :generator
+
+        # @return [Types::Base, nil]
+        attr_reader :self_type
+
+        def initialize(generator, self_type: nil)
+          @generator = generator
+          @self_type = self_type
+        end
+
+        # @param type_expression [Model::TypeExpressions::Base]
+        # @return [Base]
+        def convert_from_expression(type_expression)
+          case type_expression
+          when Model::TypeExpressions::AnyType, Model::TypeExpressions::UnknownType
+            Any.new
+          when Model::TypeExpressions::InstanceType
+            Instance.new(
+              klass: generator.find_or_build(type_expression.path),
+            )
+          when Model::TypeExpressions::ModuleType
+            is_class = %i(class meta_class).include?(generator.find(type_expression.path)&.kind)
+            Instance.new(
+              klass: generator.find_or_build_meta_class(type_expression.path),
+            )
+          when Model::TypeExpressions::SequenceType
+            # @todo Implement sequence type
+            generator.array_type
+          when Model::TypeExpressions::DuckType
+            # @todo Implement duck type
+            generator.any_type
+          when Model::TypeExpressions::SelfType
+            self_type || generator.any_type
+          when Model::TypeExpressions::ValueType
+            value_class = type_expression.value_class
+            value_class ? Instance.new(klass: generator.find_or_build(value_class)) : generator.any_type
+          when Model::TypeExpressions::UnionType
+            Union.new(*type_expression.types.map(&method(:convert_from_expression)))
+          when Model::TypeExpressions::GenericType
+            Generic.new(
+              base: convert_from_expression(type_expression.base_type),
+              type_args: type_expression.type_arguments.map(&method(:convert_from_expression)),
+            )
+          when Model::TypeExpressions::FunctionType
+            Function.new(
+              context: type_expression.context && convert_from_expression(type_expression.context),
+              return_type: convert_from_expression(type_expression.return_type),
+              parameters: type_expression.required_parameters.map(&:type).map(&method(:convert_from_expression)),
+              rest_parameter: type_expression.rest_parameter && convert_from_expression(type_expression.rest_parameter.type),
+              post_parameters: type_expression.post_parameters.map(&:type).map(&method(:convert_from_expression)),
+              keyword_parameters: (type_expression.required_keyword_parameters + type_expression.optional_keyword_parameters).map { |param| [param.name, convert_from_expression(param.type)] },
+              keyword_rest_parameter: type_expression.keyword_rest_parameter && convert_from_expression(type_expression.keyword_rest_parameter.type),
+              block_parameter: type_expression.block_parameter && convert_from_expression(type_expression.block_parameter.type),
+            )
+          else
+            fail ArgumentError, type_expression
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/function.rb

@@ -0,0 +1,68 @@
+module Yoda
+  module Typing
+    module Types
+      class Function < Base
+        # @return [Base, nil]
+        attr_reader :context
+
+        # @return [Array<Base>]
+        attr_reader :parameters
+
+        # @return [Array<Base>]
+        attr_reader :rest_parameter
+
+        # @return [Array<Base>]
+        attr_reader :post_parameters
+
+        # @return [Array<(String, Base)>]
+        attr_reader :keyword_parameters
+
+        # @return [Base]
+        attr_reader :keyword_rest_parameter
+
+        # @return [(String, Base), nil]
+        attr_reader :block_parameter
+
+        # @return [Base]
+        attr_reader :return_type
+
+        # @param context [Base, nil]
+        # @param parameters [Array<Base>]
+        # @param rest_parameter [Base, nil]
+        # @param post_parameters [Array<Base>]
+        # @param 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:, parameters: [], rest_parameter: nil, post_parameters: [], keyword_parameters: [], keyword_rest_parameter: nil, block_parameter: nil)
+          @context = context
+          @parameters = parameters
+          @keyword_parameters = keyword_parameters
+          @rest_parameter = rest_parameter
+          @post_parameters = post_parameters
+          @keyword_rest_parameter = keyword_rest_parameter
+          @block_parameter = block_parameter
+          @return_type = return_type
+        end
+
+        def to_expression
+          Model::TypeExpressions::FunctionType.new(
+            context: context&.to_expression,
+            return_type: return_type.to_expression,
+            parameters: parameters.map(&:to_expression),
+            rest_parameter: rest_parameter&.to_expression,
+            post_parameters: post_parameters.map(&:to_expression),
+            keyword_parameters: keyword_parameters.map { |keyword, type| [keyword, type.to_expression] },
+            keyword_rest_parameter: keyword_rest_parameter&.to_expression,
+            block_parameter: block_parameter&.to_expression,
+          )
+        end
+
+        def to_type_string
+          inspect
+          # "#{context.to_type_string}()"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/generator.rb

@@ -0,0 +1,306 @@
+module Yoda
+  module Typing
+    module Types
+      # Generator provides construction methods for various type classes.
+      class Generator
+        # @return [Model::Environment]
+        attr_reader :environment
+
+        # @param registry [Contexts::BaseContext]
+        def initialize(environment:)
+          @environment = environment
+        end
+
+        # @param self_type [Type]
+        # @return [Model::Environment::ValueResolveContext]
+        def value_resolve_context(self_type:)
+          Model::Environment::ValueResolveContext.new(self_type: self_type.rbs_type)
+        end
+
+        # @param [RBS::Types::t]
+        # @return [Type]
+        def wrap_rbs_type(rbs_type)
+          Type.new(environment: environment, rbs_type: rbs_type)
+        end
+
+        # @return [Type<RBS::Types::Bases::Bool>]
+        def boolean_type
+          wrap_rbs_type(RBS::Types::Bases::Bool.new(location: nil))
+        end
+
+        # @return [Type<RBS::Types::Literal>]
+        def true_type
+          literal_type(true)
+        end
+
+        # @return [Type<RBS::Types::Literal>]
+        def false_type
+          literal_type(false)
+        end
+
+        # @return [Type<RBS::Types::Bases::Nil>]
+        def nil_type
+          wrap_rbs_type(RBS::Types::Bases::Nil.new(location: nil))
+        end
+
+        # @param literal [Integer, Symbol, String, TrueClass, FalseClass]
+        # @return [Type<RBS::Types::Literal, RBS::Types::ClassInstance>]
+        def string_type(literal = nil)
+          if literal
+            literal_type(literal.to_s)
+          else
+            instance_type_at('::String')
+          end
+        end
+
+        # @param literal [Integer, Symbol, String, TrueClass, FalseClass]
+        # @return [Type<RBS::Types::Literal, RBS::Types::ClassInstance>]
+        def symbol_type(literal = nil)
+          if literal
+            literal_type(literal.to_sym)
+          else
+            instance_type_at('::Symbol')
+          end
+        end
+
+        # @param literal [Integer, Symbol, String, TrueClass, FalseClass]
+        # @return [Type<RBS::Types::Literal>]
+        def literal_type(literal)
+          wrap_rbs_type(RBS::Types::Literal.new(literal: literal, location: nil))
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def array_type
+          instance_type_at('::Array')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def hash_type
+          instance_type_at('::Hash')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def range_type
+          instance_type_at('::Range')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def regexp_type
+          instance_type_at('::RegExp')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def proc_type
+          instance_type_at('::Proc')
+        end
+
+        # @return [Type<RBS::Types::Literal, RBS::Types::ClassInstance>]
+        def integer_type(literal = nil)
+          if literal
+            literal_type(literal.to_i)
+          else
+            instance_type_at('::Integer')
+          end
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def float_type
+          instance_type_at('::Float')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def numeric_type
+          instance_type_at('::Numeric')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def object_type
+          instance_type_at('::Object')
+        end
+
+        # @param object_class [Store::Objects::NamespaceObject]
+        # @return [Type<RBS::Types::ClassInstance>]
+        def singleton_type(object_class)
+          singleton_type_at(object_class.path)
+        end
+
+        # @param object_class [Store::Objects::NamespaceObject]
+        # @return [Type<RBS::Types::ClassInstance>]
+        def instance_type(object_class)
+          instance_type_at(object_class.path)
+        end
+
+        # @param record [Hash{Symbol => RBS::Types::t}]
+        # @return [Type<RBS::Types::Record>]
+        def record_type(record)
+          wrap_rbs_type(RBS::Types::Record.new(fields: record, location: nil))
+        end
+
+        # @return [Type<RBS::Types::Bases::Any>]
+        def any_type
+          wrap_rbs_type(RBS::Types::Bases::Any.new(location: nil))
+        end
+
+        # @param reason [String, nil]
+        # @return [Type<RBS::Types::Bases::Any>]
+        def unknown_type(reason: nil)
+          Logger.trace("Use unknown type because #{reason}") if reason
+          any_type
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def class_class
+          singleton_type_at('::Class')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def module_class
+          singleton_type_at('::Module')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def object_class
+          singleton_type_at('::Object')
+        end
+
+        # @return [Type<RBS::Types::ClassInstance>]
+        def standard_error_type
+          instance_type_at('::StandardError')
+        end
+
+        # @param args [Array<Type, RBS::Types::t>]
+        # @return [Type<RBS::Types::ClassInstance>]
+        def instance_type_at(path, args: [])
+          name = to_type_name(path)
+          name ? wrap_rbs_type(RBS::Types::ClassInstance.new(name: name, args: args.map(&method(:unwrap)), location: nil)) : unknown_type(reason: "#{path} does not exists")
+        end
+
+        # @return [Type<RBS::Types::ClassSingleton>]
+        def singleton_type_at(path)
+          name = to_type_name(path)
+          name ? wrap_rbs_type(RBS::Types::ClassSingleton.new(name: name, location: nil)) : unknown_type(reason: "#{path} does not exists")
+        end
+
+        # @param types [Array<Base>]
+        # @return [Type<RBS::Types::Union>]
+        def union_type(*types)
+          wrap_rbs_type(RBS::Types::Union.new(types: types.map(&method(:unwrap)), location: nil))
+        end
+
+        # @param required_parameters [Array<Base>]
+        # @param optional_parameters [Array<Base>]
+        # @param rest_parameter [Base, nil]
+        # @param post_parameters [Array<Base>]
+        # @param required_keyword_parameters [Array<(String, Base)>]
+        # @param optional_keyword_parameters [Array<(String, Base)>]
+        # @param keyword_rest_parameter [Base, nil]
+        # @param return_type [Base]
+        # @return [Type<RBS::Types::Function>]
+        def function_type(
+          return_type:,
+          required_parameters: [],
+          optional_parameters: [],
+          rest_parameter: nil,
+          post_parameters: [],
+          required_keyword_parameters: [],
+          optional_keyword_parameters: [],
+          keyword_rest_parameter: nil
+        )
+          build_param = lambda { |type| RBS::Types::Function::Param.new(type: unwrap(type), name: nil) }
+          build_keyword = lambda { |(name, type)| [name.to_sym, RBS::Types::Function::Param.new(type: unwrap(type), name: name.to_sym)] }
+          function_type = RBS::Types::Function.new(
+            required_positionals: required_parameters.map(&build_param),
+            optional_positionals: optional_parameters.map(&build_param),
+            rest_positionals: rest_parameter&.yield_self(&build_param),
+            trailing_positionals: post_parameters.map(&build_param),
+            required_keywords: required_keyword_parameters.map(&build_keyword).to_h,
+            optional_keywords: optional_keyword_parameters.map(&build_keyword).to_h,
+            rest_keywords: keyword_rest_parameter&.yield_self(&build_param),
+            return_type: unwrap(return_type),
+          )
+          wrap_rbs_type(function_type)
+        end
+
+        # @param required_parameters [Array<Base>]
+        # @param optional_parameters [Array<Base>]
+        # @param rest_parameter [Base, nil]
+        # @param post_parameters [Array<Base>]
+        # @param required_keyword_parameters [Array<(String, Base)>]
+        # @param optional_keyword_parameters [Array<(String, Base)>]
+        # @param keyword_rest_parameter [Base, nil]
+        # @param return_type [Base]
+        # @return [RBS::MethodType]
+        def rbs_method_type(**kwargs)
+          RBS::MethodType.new(
+            type_params: [],
+            type: unwrap(function_type(**kwargs)),
+            block: nil,
+            location: nil,
+          )
+        end
+
+        # @param method_type [RBS::MethodType]
+        # @return [RBS::MethodType]
+        def fresh_params_of_method_type(method_type)
+          new_type_params = method_type.type_params.map(&method(:append_id_to_type_var))
+          new_type_variables = RBS::Types::Variable.build(new_type_params)
+
+          subst = RBS::Substitution.build(method_type.type_params, new_type_variables)
+
+          method_type.update(
+            type_params: new_type_params,
+            type: method_type.type.sub(subst),
+            block: method_type.block&.sub(subst),
+          )
+        end
+
+        private
+
+        def unwrap(type)
+          if type.respond_to?(:rbs_type)
+            type.rbs_type
+          else
+            type
+          end
+        end
+          
+
+        # @param var [Symbol]
+        # @return [Symbol]
+        def append_id_to_type_var(var)
+          "#{var}##{object_id}-#{new_id}".to_sym
+        end
+
+        # @param path [String, Path, ScopedPath]
+        # @return [RBS::TypeName, nil]
+        def to_type_name(path)
+          environment.resolve_rbs_type_name(path)
+        end
+
+        # @return [Converter]
+        def build_converter(**kwargs)
+          Converter.new(self, **kwargs)
+        end
+
+        def normalize_path(path)
+          case path
+          when Model::ScopedPath
+            path.paths.first.to_s
+          when Model::Path
+            path.to_s
+          when String, Symbol
+            path.to_s
+          else
+            fail TypeError, path
+          end
+        end
+
+        # @return [Integer]
+        def new_id
+          @id ||= 0
+          @id += 1
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/generic.rb

@@ -0,0 +1,29 @@
+module Yoda
+  module Typing
+    module Types
+      class Generic < Base
+        # @return [Base]
+        attr_reader :base
+
+        # @return [Array<Base>]
+        attr_reader :type_args
+
+        # @param base [Base]
+        # @param type_args [Array<Base>]
+        def initialize(base:, type_args:)
+          @base = base
+          @type_args = type_args
+        end
+
+        def to_expression
+          base.to_expression
+        end
+
+        def to_type_string
+          inner = type_args.map(&:to_type_string)
+          "#{base.to_type_string}<#{inner.join(', ')}>"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types/instance.rb

@@ -0,0 +1,30 @@
+module Yoda
+  module Typing
+    module Types
+      class Instance < Base
+        # @return [Stor::Objects::NamespaceObject]
+        attr_reader :klass
+
+        # @param klass [Store::Objects::NamespaceObject] class object for the instance.
+        def initialize(klass:)
+          @klass = klass
+        end
+
+        def to_expression
+          case klass.kind
+          when :meta_class
+            Model::TypeExpressions::ModuleType.new(klass.path)
+          when :class, :module
+            Model::TypeExpressions::InstanceType.new(klass.path)
+          else
+            fail NotImplementedError
+          end
+        end
+
+        def to_type_string
+          klass.path
+        end
+      end
+    end
+  end
+end