solargraph 0.58.1 → 0.58.2

data/lib/solargraph/pin/base_variable.rb

@@ -1,126 +1,126 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class BaseVariable < Base
-      # include Solargraph::Source::NodeMethods
-      include Solargraph::Parser::NodeMethods
-
-      # @return [Parser::AST::Node, nil]
-      attr_reader :assignment
-
-      attr_accessor :mass_assignment
-
-      # @param return_type [ComplexType, nil]
-      # @param mass_assignment [::Array(Parser::AST::Node, Integer), nil]
-      # @param assignment [Parser::AST::Node, nil]
-      def initialize assignment: nil, return_type: nil, mass_assignment: nil, **splat
-        super(**splat)
-        @assignment = assignment
-        # @type [nil, ::Array(Parser::AST::Node, Integer)]
-        @mass_assignment = nil
-        @return_type = return_type
-      end
-
-      def combine_with(other, attrs={})
-        new_attrs = attrs.merge({
-          assignment: assert_same(other, :assignment),
-          mass_assignment: assert_same(other, :mass_assignment),
-          return_type: combine_return_type(other),
-        })
-        super(other, new_attrs)
-      end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::VARIABLE
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        Solargraph::LanguageServer::SymbolKinds::VARIABLE
-      end
-
-      def return_type
-        @return_type ||= generate_complex_type
-      end
-
-      def nil_assignment?
-        # this will always be false - should it be return_type ==
-        #   ComplexType::NIL or somesuch?
-        return_type.nil?
-      end
-
-      def variable?
-        true
-      end
-
-      # @param parent_node [Parser::AST::Node]
-      # @param api_map [ApiMap]
-      # @return [::Array<ComplexType>]
-      def return_types_from_node(parent_node, api_map)
-        types = []
-        value_position_nodes_only(parent_node).each do |node|
-          # Nil nodes may not have a location
-          if node.nil? || node.type == :NIL || node.type == :nil
-            types.push ComplexType::NIL
-          else
-            rng = Range.from_node(node)
-            next if rng.nil?
-            pos = rng.ending
-            clip = api_map.clip_at(location.filename, pos)
-            # Use the return node for inference. The clip might infer from the
-            # first node in a method call instead of the entire call.
-            chain = Parser.chain(node, nil, nil)
-            result = chain.infer(api_map, closure, clip.locals).self_to_type(closure.context)
-            types.push result unless result.undefined?
-          end
-        end
-        types
-      end
-
-      # @param api_map [ApiMap]
-      # @return [ComplexType]
-      def probe api_map
-        unless @assignment.nil?
-          types = return_types_from_node(@assignment, api_map)
-          return ComplexType.new(types.uniq) unless types.empty?
-        end
-
-        unless @mass_assignment.nil?
-          mass_node, index = @mass_assignment
-          types = return_types_from_node(mass_node, api_map)
-          types.map! do |type|
-            if type.tuple?
-              type.all_params[index]
-            elsif ['::Array', '::Set', '::Enumerable'].include?(type.rooted_name)
-              type.all_params.first
-            end
-          end.compact!
-          return ComplexType.new(types.uniq) unless types.empty?
-        end
-
-        ComplexType::UNDEFINED
-      end
-
-      # @param other [Object]
-      def == other
-        return false unless super
-        # @sg-ignore Should add type check on other
-        assignment == other.assignment
-      end
-
-      def type_desc
-        "#{super} = #{assignment&.type.inspect}"
-      end
-
-      private
-
-      # @return [ComplexType]
-      def generate_complex_type
-        tag = docstring.tag(:type)
-        return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
-        ComplexType.new
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class BaseVariable < Base
+      # include Solargraph::Source::NodeMethods
+      include Solargraph::Parser::NodeMethods
+
+      # @return [Parser::AST::Node, nil]
+      attr_reader :assignment
+
+      attr_accessor :mass_assignment
+
+      # @param return_type [ComplexType, nil]
+      # @param mass_assignment [::Array(Parser::AST::Node, Integer), nil]
+      # @param assignment [Parser::AST::Node, nil]
+      def initialize assignment: nil, return_type: nil, mass_assignment: nil, **splat
+        super(**splat)
+        @assignment = assignment
+        # @type [nil, ::Array(Parser::AST::Node, Integer)]
+        @mass_assignment = nil
+        @return_type = return_type
+      end
+
+      def combine_with(other, attrs={})
+        new_attrs = attrs.merge({
+          assignment: assert_same(other, :assignment),
+          mass_assignment: assert_same(other, :mass_assignment),
+          return_type: combine_return_type(other),
+        })
+        super(other, new_attrs)
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::VARIABLE
+      end
+
+      # @return [Integer]
+      def symbol_kind
+        Solargraph::LanguageServer::SymbolKinds::VARIABLE
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def nil_assignment?
+        # this will always be false - should it be return_type ==
+        #   ComplexType::NIL or somesuch?
+        return_type.nil?
+      end
+
+      def variable?
+        true
+      end
+
+      # @param parent_node [Parser::AST::Node]
+      # @param api_map [ApiMap]
+      # @return [::Array<ComplexType>]
+      def return_types_from_node(parent_node, api_map)
+        types = []
+        value_position_nodes_only(parent_node).each do |node|
+          # Nil nodes may not have a location
+          if node.nil? || node.type == :NIL || node.type == :nil
+            types.push ComplexType::NIL
+          else
+            rng = Range.from_node(node)
+            next if rng.nil?
+            pos = rng.ending
+            clip = api_map.clip_at(location.filename, pos)
+            # Use the return node for inference. The clip might infer from the
+            # first node in a method call instead of the entire call.
+            chain = Parser.chain(node, nil, nil)
+            result = chain.infer(api_map, closure, clip.locals).self_to_type(closure.context)
+            types.push result unless result.undefined?
+          end
+        end
+        types
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def probe api_map
+        unless @assignment.nil?
+          types = return_types_from_node(@assignment, api_map)
+          return ComplexType.new(types.uniq) unless types.empty?
+        end
+
+        unless @mass_assignment.nil?
+          mass_node, index = @mass_assignment
+          types = return_types_from_node(mass_node, api_map)
+          types.map! do |type|
+            if type.tuple?
+              type.all_params[index]
+            elsif ['::Array', '::Set', '::Enumerable'].include?(type.rooted_name)
+              type.all_params.first
+            end
+          end.compact!
+          return ComplexType.new(types.uniq) unless types.empty?
+        end
+
+        ComplexType::UNDEFINED
+      end
+
+      # @param other [Object]
+      def == other
+        return false unless super
+        # @sg-ignore Should add type check on other
+        assignment == other.assignment
+      end
+
+      def type_desc
+        "#{super} = #{assignment&.type.inspect}"
+      end
+
+      private
+
+      # @return [ComplexType]
+      def generate_complex_type
+        tag = docstring.tag(:type)
+        return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
+        ComplexType.new
+      end
+    end
+  end
+end

data/lib/solargraph/pin/block.rb

@@ -1,104 +1,104 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Block < Callable
-      include Breakable
-
-      # @return [Parser::AST::Node]
-      attr_reader :receiver
-
-      # @return [Parser::AST::Node]
-      attr_reader :node
-
-      # @param receiver [Parser::AST::Node, nil]
-      # @param node [Parser::AST::Node, nil]
-      # @param context [ComplexType, nil]
-      # @param args [::Array<Parameter>]
-      def initialize receiver: nil, args: [], context: nil, node: nil, **splat
-        super(**splat, parameters: args)
-        @receiver = receiver
-        @context = context
-        @return_type = ComplexType.parse('::Proc')
-        @node = node
-      end
-
-      # @param api_map [ApiMap]
-      # @return [void]
-      def rebind api_map
-        @rebind ||= maybe_rebind(api_map)
-      end
-
-      def binder
-        @rebind&.defined? ? @rebind : closure.binder
-      end
-
-      # @param yield_types [::Array<ComplexType>]
-      # @param parameters [::Array<Parameter>]
-      #
-      # @return [::Array<ComplexType>]
-      def destructure_yield_types(yield_types, parameters)
-        # yielding a tuple into a block will destructure the tuple
-        if yield_types.length == 1
-          yield_type = yield_types.first
-          return yield_type.all_params if yield_type.tuple? && yield_type.all_params.length == parameters.length
-        end
-        parameters.map.with_index { |_, idx| yield_types[idx] || ComplexType::UNDEFINED }
-      end
-
-      # @param api_map [ApiMap]
-      # @return [::Array<ComplexType>]
-      def typify_parameters(api_map)
-        chain = Parser.chain(receiver, filename, node)
-        clip = api_map.clip_at(location.filename, location.range.start)
-        locals = clip.locals - [self]
-        meths = chain.define(api_map, closure, locals)
-        # @todo Convert logic to use signatures
-        # @param meth [Pin::Method]
-        meths.each do |meth|
-          next if meth.block.nil?
-
-          yield_types = meth.block.parameters.map(&:return_type)
-          # 'arguments' is what the method says it will yield to the
-          # block; 'parameters' is what the block accepts
-          argument_types = destructure_yield_types(yield_types, parameters)
-          param_types = argument_types.each_with_index.map do |arg_type, idx|
-            param = parameters[idx]
-            param_type = chain.base.infer(api_map, param, locals)
-            unless arg_type.nil?
-              if arg_type.generic? && param_type.defined?
-                namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
-                arg_type.resolve_generics(namespace_pin, param_type)
-              else
-                arg_type.self_to_type(chain.base.infer(api_map, self, locals)).qualify(api_map, *meth.gates)
-              end
-            end
-          end
-          return param_types if param_types.all?(&:defined?)
-        end
-        parameters.map { ComplexType::UNDEFINED }
-      end
-
-      private
-
-      # @param api_map [ApiMap]
-      # @return [ComplexType]
-      def maybe_rebind api_map
-        return ComplexType::UNDEFINED unless receiver
-
-        chain = Parser.chain(receiver, location.filename)
-        locals = api_map.source_map(location.filename).locals_at(location)
-        receiver_pin = chain.define(api_map, closure, locals).first
-        return ComplexType::UNDEFINED unless receiver_pin
-
-        types = receiver_pin.docstring.tag(:yieldreceiver)&.types
-        return ComplexType::UNDEFINED unless types&.any?
-
-        target = chain.base.infer(api_map, receiver_pin, locals)
-        target = full_context unless target.defined?
-
-        ComplexType.try_parse(*types).qualify(api_map, *receiver_pin.gates).self_to_type(target)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Block < Callable
+      include Breakable
+
+      # @return [Parser::AST::Node]
+      attr_reader :receiver
+
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize receiver: nil, args: [], context: nil, node: nil, **splat
+        super(**splat, parameters: args)
+        @receiver = receiver
+        @context = context
+        @return_type = ComplexType.parse('::Proc')
+        @node = node
+      end
+
+      # @param api_map [ApiMap]
+      # @return [void]
+      def rebind api_map
+        @rebind ||= maybe_rebind(api_map)
+      end
+
+      def binder
+        @rebind&.defined? ? @rebind : closure.binder
+      end
+
+      # @param yield_types [::Array<ComplexType>]
+      # @param parameters [::Array<Parameter>]
+      #
+      # @return [::Array<ComplexType>]
+      def destructure_yield_types(yield_types, parameters)
+        # yielding a tuple into a block will destructure the tuple
+        if yield_types.length == 1
+          yield_type = yield_types.first
+          return yield_type.all_params if yield_type.tuple? && yield_type.all_params.length == parameters.length
+        end
+        parameters.map.with_index { |_, idx| yield_types[idx] || ComplexType::UNDEFINED }
+      end
+
+      # @param api_map [ApiMap]
+      # @return [::Array<ComplexType>]
+      def typify_parameters(api_map)
+        chain = Parser.chain(receiver, filename, node)
+        clip = api_map.clip_at(location.filename, location.range.start)
+        locals = clip.locals - [self]
+        meths = chain.define(api_map, closure, locals)
+        # @todo Convert logic to use signatures
+        # @param meth [Pin::Method]
+        meths.each do |meth|
+          next if meth.block.nil?
+
+          yield_types = meth.block.parameters.map(&:return_type)
+          # 'arguments' is what the method says it will yield to the
+          # block; 'parameters' is what the block accepts
+          argument_types = destructure_yield_types(yield_types, parameters)
+          param_types = argument_types.each_with_index.map do |arg_type, idx|
+            param = parameters[idx]
+            param_type = chain.base.infer(api_map, param, locals)
+            unless arg_type.nil?
+              if arg_type.generic? && param_type.defined?
+                namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
+                arg_type.resolve_generics(namespace_pin, param_type)
+              else
+                arg_type.self_to_type(chain.base.infer(api_map, self, locals)).qualify(api_map, *meth.gates)
+              end
+            end
+          end
+          return param_types if param_types.all?(&:defined?)
+        end
+        parameters.map { ComplexType::UNDEFINED }
+      end
+
+      private
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def maybe_rebind api_map
+        return ComplexType::UNDEFINED unless receiver
+
+        chain = Parser.chain(receiver, location.filename)
+        locals = api_map.source_map(location.filename).locals_at(location)
+        receiver_pin = chain.define(api_map, closure, locals).first
+        return ComplexType::UNDEFINED unless receiver_pin
+
+        types = receiver_pin.docstring.tag(:yieldreceiver)&.types
+        return ComplexType::UNDEFINED unless types&.any?
+
+        target = chain.base.infer(api_map, receiver_pin, locals)
+        target = full_context unless target.defined?
+
+        ComplexType.try_parse(*types).qualify(api_map, *receiver_pin.gates).self_to_type(target)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/breakable.rb

@@ -1,9 +1,9 @@
-module Solargraph
-  module Pin
-    # Mix-in for pins which enclose code which the 'break' statement works with-in - e.g., blocks, when, until, ...
-    module Breakable
-      # @return [Parser::AST::Node]
-      attr_reader :node
-    end
-  end
-end
+module Solargraph
+  module Pin
+    # Mix-in for pins which enclose code which the 'break' statement works with-in - e.g., blocks, when, until, ...
+    module Breakable
+      # @return [Parser::AST::Node]
+      attr_reader :node
+    end
+  end
+end