yoda-language-server 0.7.2 → 0.10.0

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

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

@@ -0,0 +1,74 @@
+require 'forwardable'
+require 'yoda/typing/types/rbs_type_wrapper_interface'
+
+module Yoda
+  module Typing
+    module Types
+      class InstanceType
+        extend Forwardable
+        include RbsTypeWrapperInterface
+
+        # @return [Model::Environment]
+        delegate environment: :singleton_type
+
+        # @return [RbsTypeWrapperInterface]
+        attr_reader :singleton_type
+
+        # @param singleton_type [Type, SingletonType]
+        def initialize(singleton_type)
+          @singleton_type = singleton_type
+        end
+
+        # @return [RBS::Types::t]
+        def rbs_type
+          @rbs_type ||= make_instance(singleton_type.rbs_type)
+        end
+
+        # @return [Model::Values::Base]
+        def value
+          @value ||= singleton_type.value.instance_value
+        end
+
+        # @return [InstanceType]
+        def instance_type
+          InstanceType.new(self)
+        end
+
+        # @deprecated Use {#value} to access referred objects.
+        # @return [Store::Objects::Base]
+        def klass
+          value.referred_objects.first
+        end
+
+        # @return [String]
+        def to_s
+          rbs_type.to_s
+        end
+
+        # @param pp [PP]
+        def pretty_print(pp)
+          pp.object_group(self) do
+            pp.breakable
+            pp.text "@rbs_type="
+            pp.pp rbs_type.to_s
+          end
+        end
+
+        private
+
+        # @param rbs_type [RBS::Types::t]
+        # @return [RBS::Types::t]
+        def make_instance(rbs_type)
+          if rbs_type.is_a?(RBS::Types::ClassSingleton)
+            RBS::Types::ClassInstance.new(name: rbs_type.name, args: [], location: nil)
+          elsif rbs_type.respond_to?(:type_map)
+            rbs_type.type_map(&method(:make_instance))
+          else
+            rbs_type
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,39 @@
+module Yoda
+  module Typing
+    module Types
+      class Method < Base
+        # @return [Base]
+        attr_reader :callee
+
+        # @return [String]
+        attr_reader :method_name
+
+        # @param callee [Base]
+        # @param method_name [String]
+        # @param with_receiver [true, false]
+        def initialize(callee, method_name, with_receiver: false)
+          @callee = callee
+          @method_name = method_name
+        end
+
+        def to_expression(resolver)
+          callee_type = to_expression(callee)
+          values = callee_type.instanciate(resolver.registry)
+          Model::TypeExpressions::UnionType.new(
+            values.map do |value|
+              value.methods(visibility: visibility).select { |func| func.name == method_name }
+            end.flatten
+          )
+        end
+
+        def visilibity
+          @self_call ? [:private, :public, :protected] : [:public]
+        end
+
+        def to_type_string
+          "#{callee.to_type_string}##{method_name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Yoda
+  module Typing
+    module Types
+      module RbsTypeWrapperInterface
+        # @abstract
+        # @return [Model::Environment]
+        def environment
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [RBS::Types::t]
+        def rbs_type
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Model::Values::Base]
+        def value
+          fail NotImplemetedError
+        end
+
+        # @abstract
+        # @return [Type]
+        def instance_type
+          fail NotImplemetedError
+        end
+
+        # @abstract
+        # @return [Type]
+        def singleton_type
+          fail NotImplemetedError
+        end
+
+        # @abstract
+        # @return [String]
+        def to_s
+          fail NotImplemetedError
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,75 @@
+require 'forwardable'
+require 'yoda/typing/types/rbs_type_wrapper_interface'
+
+module Yoda
+  module Typing
+    module Types
+      class SingletonType
+        extend Forwardable
+        include RbsTypeWrapperInterface
+
+        # @return [Model::Environment]
+        delegate environment: :instance_type
+
+        # @return [Type, SingletonType]
+        attr_reader :instance_type
+
+        # @param instance_type [Type, SingletonType]
+        def initialize(instance_type)
+          @instance_type = instance_type
+        end
+
+        # @return [RBS::Types::t]
+        def rbs_type
+          @rbs_type ||= make_singleton(instance_type.rbs_type)
+        end
+
+        # @return [Model::Values::Base]
+        def value
+          @value ||= instance_type.value.singleton_class_value
+        end
+
+        # @return [SingletonType]
+        def singleton_type
+          SingletonType.new(self)
+        end
+
+        # @deprecated Use {#value} to access referred objects.
+        # @return [Store::Objects::Base]
+        def klass
+          value.referred_objects.first
+        end
+
+        # @return [String]
+        def to_s
+          rbs_type.to_s
+        end
+
+        # @param pp [PP]
+        def pretty_print(pp)
+          pp.object_group(self) do
+            pp.breakable
+            pp.text "@rbs_type="
+            pp.pp rbs_type.to_s
+          end
+        end
+
+        private
+
+        # @param rbs_type [RBS::Types::t]
+        # @return [RBS::Types::t]
+        def make_singleton(rbs_type)
+          if rbs_type.is_a?(RBS::Types::ClassInstance)
+            RBS::Types::ClassSingleton.new(name: type.name, location: nil)
+          elsif rbs_type.respond_to?(:type_map)
+            rbs_type.type_map(&method(:make_singleton))
+          else
+            rbs_type
+          end
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,24 @@
+module Yoda
+  module Typing
+    module Types
+      class Tuple < Base
+        # @return [Array<Base>]
+        attr_reader :types
+
+        # @param types [Array<Base>]
+        def initialize(*types)
+          @types = types
+        end
+
+        def to_expression
+          Model::TypeExpressions::InstanceType.new('Array')
+        end
+
+        def to_type_string
+          inner = types.map(&:to_type_string)
+          "(#{inner.join(', ')})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'yoda/typing/types/rbs_type_wrapper_interface'
+
+module Yoda
+  module Typing
+    module Types
+      class Type
+        include RbsTypeWrapperInterface
+
+        # @return [Model::Environment]
+        attr_reader :environment
+
+        # @return [RBS::Types::t]
+        attr_reader :rbs_type
+
+        # @param environment [Model::Environment]
+        # @param rbs_type [RBS::Types::t]
+        def initialize(environment:, rbs_type:)
+          @environment = environment
+          @rbs_type = rbs_type
+        end
+
+        # @return [Model::Values::Base]
+        def value
+          @value ||= environment.resolve_value_by_rbs_type(rbs_type)
+        end
+
+        # @return [InstanceType]
+        def instance_type
+          InstanceType.new(self)
+        end
+
+        # @return [SingletonType]
+        def singleton_type
+          SingletonType.new(self)
+        end
+
+        # @deprecated Use {#value} to access referred objects.
+        # @return [Store::Objects::Base]
+        def klass
+          value.referred_objects.first
+        end
+
+        # @return [String]
+        def to_s
+          rbs_type.to_s
+        end
+
+        # @param pp [PP]
+        def pretty_print(pp)
+          pp.object_group(self) do
+            pp.breakable
+            pp.text "type:"
+            pp.pp rbs_type.to_s
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,38 @@
+module Yoda
+  module Typing
+    module Types
+      class Union < Base
+        # @return [Array<Base>]
+        attr_reader :types
+
+        # @param types [Array<Base>]
+        # @return [Union, Any, Base]
+        def self.new(*types)
+          extracted_types = types.map { |type| type.is_a?(Union) ? type.types : type }.flatten
+          case extracted_types.length
+          when 0
+            Any.new
+          when 1
+            extracted_types.first
+          else
+            super(*extracted_types)
+          end
+        end
+
+        # @param types [Array<Base>]
+        def initialize(*types)
+          types.each { |type| fail TypeError, type unless type.is_a?(Types::Base) }
+          @types = types
+        end
+
+        def to_expression
+          Model::TypeExpressions::UnionType.new(types.map(&:to_expression))
+        end
+
+        def to_type_string
+          types.map(&:to_type_string).join(" | ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'securerandom'
+
+module Yoda
+  module Typing
+    module Types
+      class Var < Base
+        def initialize(label = nil, ref = nil)
+          @id = SecureRandom.alphanumeric(20)
+          @label = label
+          @ref = ref
+        end
+
+        # @param new_ref [Base]
+        def ref=(new_ref)
+          return if new_ref == self
+          @ref = new_ref
+        end
+
+        def reference?
+          true
+        end
+
+        # @return [Base, nil]
+        def ref
+          @ref&.ref
+        end
+
+        def to_expression
+          ref&.to_expression || Store::TypeExpressions::UnknownType.new
+        end
+
+        def to_type_string
+          ref ? ref.to_type_string : "var(#{label}:#{id})"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/types.rb

@@ -0,0 +1,24 @@
+module Yoda
+  module Typing
+    module Types
+      require 'yoda/typing/types/base'
+      require 'yoda/typing/types/any'
+      require 'yoda/typing/types/generic'
+      require 'yoda/typing/types/instance'
+      require 'yoda/typing/types/function'
+      require 'yoda/typing/types/method'
+      require 'yoda/typing/types/var'
+      require 'yoda/typing/types/associative_array'
+      require 'yoda/typing/types/tuple'
+      require 'yoda/typing/types/union'
+
+      require 'yoda/typing/types/generator'
+      require 'yoda/typing/types/converter'
+
+      require 'yoda/typing/types/instance_type'
+      require 'yoda/typing/types/rbs_type_wrapper_interface'
+      require 'yoda/typing/types/singleton_type'
+      require 'yoda/typing/types/type'
+    end
+  end
+end

data/lib/yoda/typing.rb

@@ -1,10 +1,14 @@
 module Yoda
   module Typing
-    require 'yoda/typing/context'
+    require 'yoda/typing/constant_resolver'
+    require 'yoda/typing/contexts'
     require 'yoda/typing/environment'
-    require 'yoda/typing/evaluator'
     require 'yoda/typing/relation'
     require 'yoda/typing/traces'
     require 'yoda/typing/lexical_scope'
+    require 'yoda/typing/types'
+    require 'yoda/typing/tree'
+    require 'yoda/typing/inferencer'
+    require 'yoda/typing/node_info'
   end
 end

data/lib/yoda/version.rb

@@ -1,3 +1,3 @@
 module Yoda
-  VERSION = "0.7.2"
+  VERSION = "0.10.0"
 end

data/lib/yoda.rb

@@ -1,10 +1,15 @@
 module Yoda
   require "yoda/version"
   require "yoda/logger"
+  require "yoda/has_services"
+  require "yoda/missing_delegatable"
+
   require "yoda/instrument"
-  require "yoda/commands"
+  require "yoda/ast"
+  require "yoda/cli"
   require "yoda/errors"
-  require "yoda/evaluation"
+  require "yoda/id_mask"
+  require "yoda/services"
   require "yoda/model"
   require "yoda/store"
   require "yoda/server"

data/scripts/benchmark.rb

@@ -2,5 +2,5 @@ require 'yoda'
 require 'benchmark'
 
 Benchmark.bm do |b|
-  b.report { Yoda::Commands::Setup.run(dir: File.expand_path('../spec/support/fixtures', __dir__), force_build: true) }
+  b.report { Yoda::Store.setup(dir: File.expand_path('../spec/support/fixtures', __dir__), force_build: true) }
 end

data/yoda-language-server.gemspec

@@ -21,23 +21,24 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'yard', '~> 0.9.11'
-  spec.add_dependency 'thor', '~> 0.20.0'
-  spec.add_dependency 'parslet', '~> 1.8'
-  spec.add_dependency 'parser', '~> 2.0'
-  spec.add_dependency 'unparser', '~> 0.2.6'
-  spec.add_dependency 'language_server-protocol', '~> 3.12.0.0'
-  spec.add_dependency 'leveldb', '~> 0.1.9'
-  spec.add_dependency 'lmdb', '~> 0.4.8'
+  spec.add_dependency 'yard'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'parslet'
+  spec.add_dependency 'parser'
+  spec.add_dependency 'unparser'
+  spec.add_dependency 'language_server-protocol'
+  spec.add_dependency 'rbs', "~> 2.0"
+  spec.add_dependency 'gdbm'
   spec.add_dependency 'ruby-progressbar'
-  spec.add_dependency 'concurrent-ruby', '~> 1.0.0'
+  spec.add_dependency 'concurrent-ruby', '~> 1.1.0'
+  spec.add_dependency 'rubyzip', '>= 1.0.0'
 
-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rspec-benchmark", "~> 0.3"
-  spec.add_development_dependency "pry", "~> 0.11"
-  spec.add_development_dependency "pry-rescue", "~> 1.4"
-  spec.add_development_dependency "pry-stack_explorer", "~> 0.4"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-benchmark"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-rescue"
+  spec.add_development_dependency "pry-stack_explorer"
   spec.add_development_dependency "stackprof"
 end