yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/typing/constant_resolver.rb

@@ -0,0 +1,105 @@
+require 'forwardable'
+
+module Yoda
+  module Typing
+    class ConstantResolver
+      require 'yoda/typing/constant_resolver/cbase_query'
+      require 'yoda/typing/constant_resolver/member_query'
+      require 'yoda/typing/constant_resolver/node_tracer'
+      require 'yoda/typing/constant_resolver/query'
+      require 'yoda/typing/constant_resolver/relative_base_query'
+
+      extend Forwardable
+
+      # @return [Contexts::BaseContext]
+      attr_reader :context
+
+      # @return [Types::Generator]
+      delegate [:generator] => :context
+
+      # @param context [ContextsBaseContext]
+      def initialize(context:)
+        @context = context
+      end
+
+      # @param node [AST::ConstantNode]
+      # @param tracer [Inferncer::Tracer]
+      # @return [ConstantScope::Query]
+      def build_query_for_node(node, tracer:)
+        Query.from_node(node, tracer: tracer)
+      end
+
+      # @param node [AST::ConstantNode]
+      # @param tracer [Inferncer::Tracer]
+      # @return [Types::Base]
+      def resolve_node(node, tracer:)
+        query = Query.from_node(node, tracer: tracer)
+        resolve(query)
+      end
+
+      # @param path [String]
+      # @return [Types::Base]
+      def resolve_path(path)
+        query = Query.from_string(path.to_s)
+        resolve(query)
+      end
+
+      # @param query [ConstantScope::Query]
+      # @return [Types::Base]
+      def resolve(query)
+        query.tracer&.bind_context(context: context)
+        type = infer(query)
+        query.tracer&.bind_type(type: type, context: context)
+        type
+      end
+
+      private
+
+      def infer(query)
+        case query.parent
+        when CbaseQuery
+          # Remember constant candidates
+          constants = [context.environment.resolve_constant(query.name.to_s)].compact
+
+          query.tracer&.bind_constants(constants: constants)
+
+          generator.singleton_type_at("::#{query.name}")
+        when RelativeBaseQuery
+          lexical_values = context.lexical_scope_types.map(&:value)
+          relative_path = query.name.to_s
+
+          # Search nearest lexical scope first
+          found_paths = lexical_values.reverse.reduce(nil) do |found_paths, value|
+            found_paths || begin
+              current_found_paths = value.select_constant_paths(relative_path)
+              current_found_paths.empty? ? nil : current_found_paths
+            end
+          end
+
+          if found_paths
+            # Remember constant candidates
+            constants = [context.environment.resolve_constant(found_paths.first)].compact
+
+            query.tracer&.bind_constants(constants: constants)
+
+            generator.singleton_type_at(found_paths.first)
+          else
+            generator.any_type
+          end
+        when MemberQuery
+          base_type = resolve(query.parent)
+
+          # Remember constant candidates
+          paths = base_type.value.select_constant_paths(query.name.to_s)
+          constants = paths.map { |path| context.environment.resolve_constant(path) }.compact
+
+          query.tracer&.bind_constants(constants: constants)
+
+          generator.wrap_rbs_type(base_type.value.select_constant_type(query.name.to_s))
+        else
+          fail "unexpected"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/typing/contexts/base_context.rb

@@ -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

data/lib/yoda/typing/contexts/block_context.rb

@@ -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

data/lib/yoda/typing/contexts/context_derivation.rb

@@ -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

data/lib/yoda/typing/contexts/method_context.rb

@@ -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

data/lib/yoda/typing/contexts/namespace_block_context.rb

@@ -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

data/lib/yoda/typing/contexts/namespace_context.rb

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

data/lib/yoda/typing/contexts.rb

@@ -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

data/lib/yoda/typing/environment.rb

@@ -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

data/lib/yoda/typing/inferencer/arguments.rb

@@ -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

data/lib/yoda/typing/inferencer/arguments_binder.rb

@@ -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