solargraph 0.46.0 → 0.47.1

data/lib/solargraph/pin/base_variable.rb

@@ -1,84 +1,84 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class BaseVariable < Base
-      include Solargraph::Parser::NodeMethods
-      # include Solargraph::Source::NodeMethods
-
-      # @return [Parser::AST::Node, nil]
-      attr_reader :assignment
-
-      # @param assignment [Parser::AST::Node, nil]
-      def initialize assignment: nil, **splat
-        super(**splat)
-        @assignment = assignment
-      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?
-        return_type.nil?
-      end
-
-      def variable?
-        true
-      end
-
-      def probe api_map
-        return ComplexType::UNDEFINED if @assignment.nil?
-        types = []
-        returns_from(@assignment).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, clip.in_block?)
-            result = chain.infer(api_map, closure, clip.locals)
-            types.push result unless result.undefined?
-          end
-        end
-        return ComplexType::UNDEFINED if types.empty?
-        ComplexType.try_parse(*types.map(&:tag))
-      end
-
-      def == other
-        return false unless super
-        assignment == other.assignment
-      end
-
-      def try_merge! pin
-        return false unless super
-        @assignment = pin.assignment
-        @return_type = pin.return_type
-        true
-      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::Parser::NodeMethods
+      # include Solargraph::Source::NodeMethods
+
+      # @return [Parser::AST::Node, nil]
+      attr_reader :assignment
+
+      # @param assignment [Parser::AST::Node, nil]
+      def initialize assignment: nil, **splat
+        super(**splat)
+        @assignment = assignment
+      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?
+        return_type.nil?
+      end
+
+      def variable?
+        true
+      end
+
+      def probe api_map
+        return ComplexType::UNDEFINED if @assignment.nil?
+        types = []
+        returns_from(@assignment).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, clip.in_block?)
+            result = chain.infer(api_map, closure, clip.locals)
+            types.push result unless result.undefined?
+          end
+        end
+        return ComplexType::UNDEFINED if types.empty?
+        ComplexType.try_parse(*types.map(&:tag))
+      end
+
+      def == other
+        return false unless super
+        assignment == other.assignment
+      end
+
+      def try_merge! pin
+        return false unless super
+        @assignment = pin.assignment
+        @return_type = pin.return_type
+        true
+      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,72 +1,73 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Block < Closure
-      # The signature of the method that receives this block.
-      #
-      # @return [Parser::AST::Node]
-      attr_reader :receiver
-
-      def initialize receiver: nil, args: [], context: nil, **splat
-        super(**splat)
-        @receiver = receiver
-        @context = context
-        @parameters = args
-      end
-
-      # @param api_map [ApiMap]
-      # @return [void]
-      def rebind api_map
-        @binder ||= binder_or_nil(api_map)
-      end
-
-      def binder
-        @binder || closure.binder
-      end
-
-      # @return [Array<String>]
-      def parameters
-        @parameters ||= []
-      end
-
-      # @return [Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map(&:name)
-      end
-
-      private
-
-      # @param api_map [ApiMap]
-      # @return [ComplexType, nil]
-      def binder_or_nil api_map
-        return nil unless receiver
-        word = receiver.children.find { |c| c.is_a?(::Symbol) }.to_s
-        return nil unless api_map.rebindable_method_names.include?(word)
-        chain = Parser.chain(receiver, location.filename)
-        locals = api_map.source_map(location.filename).locals_at(location)
-        links_last_word = chain.links.last.word
-        if %w[instance_eval instance_exec class_eval class_exec module_eval module_exec].include?(links_last_word)
-          return chain.base.infer(api_map, self, locals)
-        end
-        if 'define_method' == links_last_word and chain.define(api_map, self, locals).first&.path == 'Module#define_method' # change class type to instance type
-          if chain.links.size > 1 # Class.define_method
-            ty = chain.base.infer(api_map, self, locals)
-            return Solargraph::ComplexType.parse(ty.namespace)
-          else # define_method without self
-            return Solargraph::ComplexType.parse(closure.binder.namespace)
-          end
-        end
-        # other case without early return, read block yieldself tags
-        receiver_pin = chain.define(api_map, self, locals).first
-        if receiver_pin && receiver_pin.docstring
-          ys = receiver_pin.docstring.tag(:yieldself)
-          if ys && ys.types && !ys.types.empty?
-            return ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
-          end
-        end
-        nil
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Block < Closure
+      # The signature of the method that receives this block.
+      #
+      # @return [Parser::AST::Node]
+      attr_reader :receiver
+
+      # @param args [Array<Parameter>]
+      def initialize receiver: nil, args: [], context: nil, **splat
+        super(**splat)
+        @receiver = receiver
+        @context = context
+        @parameters = args
+      end
+
+      # @param api_map [ApiMap]
+      # @return [void]
+      def rebind api_map
+        @binder ||= binder_or_nil(api_map)
+      end
+
+      def binder
+        @binder || closure.binder
+      end
+
+      # @return [Array<Parameter>]
+      def parameters
+        @parameters ||= []
+      end
+
+      # @return [Array<String>]
+      def parameter_names
+        @parameter_names ||= parameters.map(&:name)
+      end
+
+      private
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def binder_or_nil api_map
+        return nil unless receiver
+        word = receiver.children.find { |c| c.is_a?(::Symbol) }.to_s
+        return nil unless api_map.rebindable_method_names.include?(word)
+        chain = Parser.chain(receiver, location.filename)
+        locals = api_map.source_map(location.filename).locals_at(location)
+        links_last_word = chain.links.last.word
+        if %w[instance_eval instance_exec class_eval class_exec module_eval module_exec].include?(links_last_word)
+          return chain.base.infer(api_map, self, locals)
+        end
+        if 'define_method' == links_last_word and chain.define(api_map, self, locals).first&.path == 'Module#define_method' # change class type to instance type
+          if chain.links.size > 1 # Class.define_method
+            ty = chain.base.infer(api_map, self, locals)
+            return Solargraph::ComplexType.parse(ty.namespace)
+          else # define_method without self
+            return Solargraph::ComplexType.parse(closure.binder.namespace)
+          end
+        end
+        # other case without early return, read block yieldself tags
+        receiver_pin = chain.define(api_map, self, locals).first
+        if receiver_pin && receiver_pin.docstring
+          ys = receiver_pin.docstring.tag(:yieldself)
+          if ys && ys.types && !ys.types.empty?
+            return ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/solargraph/pin/class_variable.rb

@@ -1,8 +1,8 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class ClassVariable < BaseVariable
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class ClassVariable < BaseVariable
+    end
+  end
+end

data/lib/solargraph/pin/closure.rb

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Closure < Base
-      # @return [::Symbol] :class or :instance
-      attr_reader :scope
-
-      def initialize scope: :class, **splat
-        super(**splat)
-        @scope = scope
-      end
-
-      def context
-        @context ||= begin
-          result = super
-          if scope == :instance
-            Solargraph::ComplexType.parse(result.namespace)
-          else
-            result
-          end
-        end
-      end
-
-      def binder
-        @binder || context
-      end
-
-      # @return [Array<String>]
-      def gates
-        # @todo This check might not be necessary. There should always be a
-        #   root pin
-        closure ? closure.gates : ['']
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Closure < Base
+      # @return [::Symbol] :class or :instance
+      attr_reader :scope
+
+      def initialize scope: :class, **splat
+        super(**splat)
+        @scope = scope
+      end
+
+      def context
+        @context ||= begin
+          result = super
+          if scope == :instance
+            Solargraph::ComplexType.parse(result.namespace)
+          else
+            result
+          end
+        end
+      end
+
+      def binder
+        @binder || context
+      end
+
+      # @return [Array<String>]
+      def gates
+        # @todo This check might not be necessary. There should always be a
+        #   root pin
+        closure ? closure.gates : ['']
+      end
+    end
+  end
+end

data/lib/solargraph/pin/common.rb

@@ -1,70 +1,70 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    module Common
-      # @return [Location]
-      attr_reader :location
-
-      # @return [Pin::Base, nil]
-      attr_reader :closure
-
-      # @return [String]
-      def name
-        @name ||= ''
-      end
-
-      # @return [ComplexType]
-      def return_type
-        @return_type ||= ComplexType::UNDEFINED
-      end
-
-      # @return [ComplexType]
-      def context
-        # Get the static context from the nearest namespace
-        @context ||= find_context
-      end
-      alias full_context context
-
-      # @return [String]
-      def namespace
-        context.namespace.to_s
-      end
-
-      # @return [ComplexType]
-      def binder
-        @binder || context
-      end
-
-      # @return [String]
-      def comments
-        @comments ||= ''
-      end
-
-      # @return [String]
-      def path
-        @path ||= name.empty? ? context.namespace : "#{context.namespace}::#{name}"
-      end
-
-      private
-
-      # @return [ComplexType]
-      def find_context
-        here = closure
-        until here.nil?
-          if here.is_a?(Pin::Namespace)
-            return here.return_type
-          elsif here.is_a?(Pin::Method)
-            if here.scope == :instance
-              return ComplexType.try_parse(here.context.namespace)
-            else
-              return here.context
-            end
-          end
-          here = here.closure
-        end
-        ComplexType::ROOT
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    module Common
+      # @return [Location]
+      attr_reader :location
+
+      # @return [Pin::Base, nil]
+      attr_reader :closure
+
+      # @return [String]
+      def name
+        @name ||= ''
+      end
+
+      # @return [ComplexType]
+      def return_type
+        @return_type ||= ComplexType::UNDEFINED
+      end
+
+      # @return [ComplexType]
+      def context
+        # Get the static context from the nearest namespace
+        @context ||= find_context
+      end
+      alias full_context context
+
+      # @return [String]
+      def namespace
+        context.namespace.to_s
+      end
+
+      # @return [ComplexType]
+      def binder
+        @binder || context
+      end
+
+      # @return [String]
+      def comments
+        @comments ||= ''
+      end
+
+      # @return [String]
+      def path
+        @path ||= name.empty? ? context.namespace : "#{context.namespace}::#{name}"
+      end
+
+      private
+
+      # @return [ComplexType]
+      def find_context
+        here = closure
+        until here.nil?
+          if here.is_a?(Pin::Namespace)
+            return here.return_type
+          elsif here.is_a?(Pin::Method)
+            if here.scope == :instance
+              return ComplexType.try_parse(here.context.namespace)
+            else
+              return here.context
+            end
+          end
+          here = here.closure
+        end
+        ComplexType::ROOT
+      end
+    end
+  end
+end

data/lib/solargraph/pin/constant.rb

@@ -1,43 +1,43 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Constant < BaseVariable
-      attr_reader :visibility
-
-      def initialize visibility: :public, **splat
-        super(**splat)
-        @visibility = visibility
-      end
-
-      def return_type
-        @return_type ||= generate_complex_type
-      end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::CONSTANT
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        LanguageServer::SymbolKinds::CONSTANT
-      end
-
-      def path
-        @path ||= context.namespace.to_s.empty? ? name : "#{context.namespace}::#{name}"
-      end
-
-      private
-
-      # @return [ComplexType]
-      def generate_complex_type
-        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
-        if tags.empty?
-          tags = docstring.tags(:type).map(&:types).flatten.reject(&:nil?)
-        end
-        return ComplexType::UNDEFINED if tags.empty?
-        ComplexType.try_parse *tags
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Constant < BaseVariable
+      attr_reader :visibility
+
+      def initialize visibility: :public, **splat
+        super(**splat)
+        @visibility = visibility
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::CONSTANT
+      end
+
+      # @return [Integer]
+      def symbol_kind
+        LanguageServer::SymbolKinds::CONSTANT
+      end
+
+      def path
+        @path ||= context.namespace.to_s.empty? ? name : "#{context.namespace}::#{name}"
+      end
+
+      private
+
+      # @return [ComplexType]
+      def generate_complex_type
+        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
+        if tags.empty?
+          tags = docstring.tags(:type).map(&:types).flatten.reject(&:nil?)
+        end
+        return ComplexType::UNDEFINED if tags.empty?
+        ComplexType.try_parse *tags
+      end
+    end
+  end
+end