RubyGems - yoda-language-server - Versions diffs - 0.7.2 → 0.8.0 - Mend

@@ -0,0 +1,83 @@
+require 'forwardable'
+require 'yoda/typing/contexts/context_derivation'
+module Yoda
+  module Typing
+    module Contexts
+      # @abstract
+      class BaseContext
+        extend Forwardable
+        include ContextDerivation
+        # @return [Model::Environment]
+        attr_reader :environment
+        # @return [Types::Type]
+        attr_reader :receiver
+        # @return [Types::Type]
+        attr_reader :constant_ref
+        # @return [BaseContext, nil]
+        attr_reader :parent
+        # @return [Inferencer::TypeBinding]
+        attr_reader :type_binding
+        delegate [:resolve_value_by_rbs_type]
+        # @param environment   [Model::Environment]
+        # @param receiver      [Types::Type] represents who is self of the code.
+        # @param constant_ref  [Types::Type] represents who is self of the code.
+        # @param parent        [BaseContext, nil]
+        # @param binds         [Hash{Symbol => RBS::Types::t}, nil]
+        def initialize(environment:, receiver:, constant_ref:, parent: nil, binds: nil)
+          @environment = environment
+          @receiver = receiver
+          @constant_ref = constant_ref
+          @parent = parent
+          @type_binding = Inferencer::TypeBinding.new(parent: parent_variable_scope_context&.type_binding, binds: binds)
+        end
+        # @deprecated Use methods of {BaseContext} instead.
+        def registry
+          environment.registry
+        end
+        def method_receiver
+          constant_ref.instance_type
+        end
+        # @abstract
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          fail NotImplementedError
+        end
+        # @return [Array<Types::Type>]
+        def lexical_scope_types
+          @lexical_scope_types ||= begin
+            parent_types = parent&.lexical_scope_types || []
+            if parent.nil?
+              [constant_ref]
+            elsif parent && constant_ref != parent.constant_ref
+              parent_types + [constant_ref]
+            else
+              parent_types
+            end
+          end
+        end
+        # @return [Types::Generator]
+        def generator
+          Types::Generator.new(environment: environment)
+        end
+        # @return [ConstantResolver]
+        def constant_resolver
+          ConstantResolver.new(context: self)
+        end
+      end
+    end
+  end
+end

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+module Yoda
+  module Typing
+    module Contexts
+      class BlockContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          parent
+        end
+      end
+    end
+  end
+end

@@ -0,0 +1,59 @@
+module Yoda
+  module Typing
+    module Contexts
+      module ContextDerivation
+        # @abstract
+        # @return [Model::Environment]
+        def environment
+          fail NotImplementedError
+        end
+        # @abstract
+        # @return [Types::Type]
+        def receiver
+          fail NotImplementedError
+        end
+        # @abstract
+        # @return [Types::Type]
+        def constant_ref
+          fail NotImplementedError
+        end
+        # @param class_type [Types::Type]
+        def derive_class_context(class_type:)
+          NamespaceContext.new(
+            parent: self,
+            environment: environment,
+            receiver: class_type,
+            constant_ref: class_type,
+          )
+        end
+        # @param receiver_type [Types::Type]
+        # @param binds         [Hash{Symbol => Types::Type}, nil]
+        def derive_method_context(receiver_type:, binds:)
+          MethodContext.new(
+            parent: self,
+            environment: environment,
+            receiver: receiver_type,
+            constant_ref: constant_ref,
+            binds: binds,
+          )
+        end
+        # @param receiver_type [Types::Type]
+        # @param binds         [Hash{Symbol => Types::Type}, nil]
+        def derive_block_context(binds:, receiver_type: nil)
+          BlockContext.new(
+            parent: self,
+            environment: environment,
+            receiver: receiver_type || receiver,
+            constant_ref: constant_ref,
+            binds: binds,
+          )
+        end
+      end
+    end
+  end
+end

@@ -0,0 +1,14 @@
+require 'yoda/typing/contexts/base_context'
+module Yoda
+  module Typing
+    module Contexts
+      class MethodContext < BaseContext
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          nil
+        end
+      end
+    end
+  end
+end

@@ -0,0 +1,29 @@
+require 'yoda/typing/contexts/base_context'
+module Yoda
+  module Typing
+    module Contexts
+      # Block context which has its lexical scope (for instance_eval and instance_exec)
+      class NamespaceBlockContext < BaseContext
+        # @return [Store::Objects::NamespaceObject]
+        attr_reader :objects
+        # @param namespaces [Array<Store::Objects::NamespaceObject>] namespace objects which context resolution and method definition refer
+        def initialize(objects:, **kwargs)
+          @objects = objects
+          super(**kwargs)
+        end
+        # @return [Array<Store::Objects::NamespaceObject>]
+        def current_objects
+          objects
+        end
+        # @return [Context, nil]
+        def parent_variable_scope_context
+          parent
+        end
+      end
+    end
+  end
+end

@@ -0,0 +1,25 @@
+module Yoda
+  module Typing
+    module Contexts
+      require 'yoda/typing/contexts/base_context'
+      require 'yoda/typing/contexts/block_context'
+      require 'yoda/typing/contexts/method_context'
+      require 'yoda/typing/contexts/namespace_block_context'
+      require 'yoda/typing/contexts/namespace_context'
+      # @return [NamespaceContext]
+      def self.root_scope(environment:)
+        generator = Types::Generator.new(environment: environment)
+        object_type = generator.instance_type_at("::Object")
+        object_class_type = generator.singleton_type_at("::Object")
+        NamespaceContext.new(
+          environment: environment,
+          receiver: object_type,
+          constant_ref: object_class_type,
+        )
+      end
+    end
+  end
+end

@@ -13,7 +13,7 @@ module Yoda
       end
       # @param key  [String, Symbol]
-      # @param type [Symbol, Model::Types::Base]
+      # @param type [Symbol, Model::TypeExpressions::Base]
       def bind(key, type)
         key = key.to_sym
         type = (type.is_a?(Symbol) && resolve(type)) || type

@@ -0,0 +1,38 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class Arguments
+        # @param argument_nodes [Array<AST::Node>]
+        # @param tracer [Tracer]
+        def initialize(argument_nodes, tracer)
+          @argument_nodes = argument_nodes
+          @tracer = tracer
+        end
+        # @param signature [Model::FunctionSignatures::Base]
+        # @return [Boolean]
+        def accepted_by?(signature)
+          signature.parameters
+        end
+        # @param nodes [Array<::AST::Node>]
+        # @return [{Symbol => Types::Base}]
+        def infer_argument_nodes(argument_nodes)
+          argument_nodes.each_with_object({}) do |node, obj|
+            case node.type
+            when :splat
+              # TODO
+              infer(node)
+            when :block_pass
+              obj[:block_argument] = infer(node.children.first)
+            else
+              obj[:arguments] ||= []
+              obj[:arguments].push(infer(node))
+            end
+          end
+        end
+      end
+    end
+  end
+end

@@ -0,0 +1,24 @@
+module Yoda
+  module Typing
+    class Inferencer
+      class ArgumentsBinder
+        # @return [Types::Generator]
+        attr_reader :generator
+        # @param generator [Types::Generator]
+        def initialize(generator:)
+          @generator = generator
+        end
+        # @param types [Array<RBS::MethodTypej>]
+        # @param arguments [Model::Parameters]
+        # @return [Hash{ Symbol => Types::Type }]
+        def bind(types:, arguments:)
+          binds = types.map { |type| ParameterBinder.new(arguments).bind(type: type, generator: generator) }
+          # @todo Select only one signature to bind arguments
+          binds.reduce({}) { |memo, bind| memo.merge!(bind.to_h) { |_key, v1, v2| generator.union_type(v1, v2) } }
+        end
+      end
+    end
+  end
+end

yoda-language-server 0.7.2 → 0.8.0