solargraph 0.45.0 → 0.46.0

data/lib/solargraph/pin/namespace.rb

@@ -1,91 +1,91 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Namespace < Closure
-      # @return [::Symbol] :public or :private
-      attr_reader :visibility
-
-      # @return [::Symbol] :class or :module
-      attr_reader :type
-
-      # @param type [::Symbol] :class or :module
-      # @param visibility [::Symbol] :public or :private
-      # @param gates [Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], **splat
-        # super(location, namespace, name, comments)
-        super(**splat)
-        @type = type
-        @visibility = visibility
-        if name.start_with?('::')
-          @name = name[2..-1]
-          @closure = Solargraph::Pin::ROOT_PIN
-        end
-        @open_gates = gates
-        if @name.include?('::')
-          # In this case, a chained namespace was opened (e.g., Foo::Bar)
-          # but Foo does not exist.
-          parts = @name.split('::')
-          @name = parts.pop
-          closure_name = if [Solargraph::Pin::ROOT_PIN, nil].include?(closure)
-            ''
-          else
-            closure.full_context.namespace + '::'
-          end
-          closure_name += parts.join('::')
-          @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
-          @context = nil
-        end
-      end
-
-      def namespace
-        context.namespace
-      end
-
-      def full_context
-        @full_context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
-      end
-
-      def binder
-        full_context
-      end
-
-      def scope
-        context.scope
-      end
-
-      def completion_item_kind
-        (type == :class ? LanguageServer::CompletionItemKinds::CLASS : LanguageServer::CompletionItemKinds::MODULE)
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        (type == :class ? LanguageServer::SymbolKinds::CLASS : LanguageServer::SymbolKinds::MODULE)
-      end
-
-      def path
-        @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
-      end
-
-      def return_type
-        @return_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
-      end
-
-      def domains
-        @domains ||= []
-      end
-
-      def typify api_map
-        return_type
-      end
-
-      def gates
-        @gates ||= if path.empty?
-          @open_gates
-        else
-          [path] + @open_gates
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Namespace < Closure
+      # @return [::Symbol] :public or :private
+      attr_reader :visibility
+
+      # @return [::Symbol] :class or :module
+      attr_reader :type
+
+      # @param type [::Symbol] :class or :module
+      # @param visibility [::Symbol] :public or :private
+      # @param gates [Array<String>]
+      def initialize type: :class, visibility: :public, gates: [''], **splat
+        # super(location, namespace, name, comments)
+        super(**splat)
+        @type = type
+        @visibility = visibility
+        if name.start_with?('::')
+          @name = name[2..-1]
+          @closure = Solargraph::Pin::ROOT_PIN
+        end
+        @open_gates = gates
+        if @name.include?('::')
+          # In this case, a chained namespace was opened (e.g., Foo::Bar)
+          # but Foo does not exist.
+          parts = @name.split('::')
+          @name = parts.pop
+          closure_name = if [Solargraph::Pin::ROOT_PIN, nil].include?(closure)
+            ''
+          else
+            closure.full_context.namespace + '::'
+          end
+          closure_name += parts.join('::')
+          @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
+          @context = nil
+        end
+      end
+
+      def namespace
+        context.namespace
+      end
+
+      def full_context
+        @full_context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
+      end
+
+      def binder
+        full_context
+      end
+
+      def scope
+        context.scope
+      end
+
+      def completion_item_kind
+        (type == :class ? LanguageServer::CompletionItemKinds::CLASS : LanguageServer::CompletionItemKinds::MODULE)
+      end
+
+      # @return [Integer]
+      def symbol_kind
+        (type == :class ? LanguageServer::SymbolKinds::CLASS : LanguageServer::SymbolKinds::MODULE)
+      end
+
+      def path
+        @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
+      end
+
+      def return_type
+        @return_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
+      end
+
+      def domains
+        @domains ||= []
+      end
+
+      def typify api_map
+        return_type
+      end
+
+      def gates
+        @gates ||= if path.empty?
+          @open_gates
+        else
+          [path] + @open_gates
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/parameter.rb

@@ -1,203 +1,201 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Parameter < LocalVariable
-      attr_reader :decl
-
-      attr_reader :asgn_code
-
-      def initialize decl: :arg, asgn_code: nil, **splat
-        super(**splat)
-        @asgn_code = asgn_code
-        @decl = decl
-      end
-
-      def keyword?
-        [:kwarg, :kwoptarg].include?(decl)
-      end
-
-      def kwrestarg?
-        decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
-      end
-
-      def restarg?
-        decl == :restarg
-      end
-
-      def rest?
-        decl == :restarg || decl == :kwrestarg
-      end
-
-      def full
-        case decl
-        when :optarg
-          "#{name} = #{asgn_code}"
-        when :kwarg
-          "#{name}:"
-        when :kwoptarg
-          "#{name}: #{asgn_code}"
-        when :restarg
-          "*#{name}"
-        when :kwrestarg
-          "**#{name}"
-        when :block, :blockarg
-          "&#{name}"
-        else
-          name
-        end
-      end
-
-      def return_type
-        if @return_type.nil?
-          @return_type = ComplexType::UNDEFINED
-          found = param_tag
-          @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
-          if @return_type.undefined?
-            if decl == :restarg
-              @return_type = ComplexType.try_parse('Array')
-            elsif decl == :kwrestarg
-              @return_type = ComplexType.try_parse('Hash')
-            elsif decl == :blockarg
-              @return_type = ComplexType.try_parse('Proc')
-            end
-          end
-        end
-        super
-        @return_type
-      end
-
-      # The parameter's zero-based location in the block's signature.
-      #
-      # @return [Integer]
-      def index
-        closure.parameter_names.index(name)
-      end
-
-      # @param api_map [ApiMap]
-      def typify api_map
-        return return_type.qualify(api_map, closure.context.namespace) unless return_type.undefined?
-        closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
-      end
-
-      def documentation
-        tag = param_tag
-        return '' if tag.nil? || tag.text.nil?
-        tag.text
-      end
-
-      def try_merge! pin
-        return false unless super && closure == pin.closure
-        true
-      end
-
-      def probe api_map
-        typify api_map
-      end
-
-      private
-
-      # @return [YARD::Tags::Tag]
-      def param_tag
-        found = nil
-        params = closure.docstring.tags(:param)
-        params.each do |p|
-          next unless p.name == name
-          found = p
-          break
-        end
-        if found.nil? and !index.nil?
-          found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
-        end
-        found
-      end
-
-      # @param api_map [ApiMap]
-      # @return [ComplexType]
-      def typify_block_param api_map
-        if closure.is_a?(Pin::Block) && closure.receiver
-          chain = Parser.chain(closure.receiver, filename)
-          clip = api_map.clip_at(location.filename, location.range.start)
-          locals = clip.locals - [self]
-          meths = chain.define(api_map, closure, locals)
-          meths.each do |meth|
-            if meth.docstring.has_tag?(:yieldparam_single_parameter)
-              type = chain.base.infer(api_map, closure, locals)
-              if type.defined? && !type.subtypes.empty?
-                bmeth = chain.base.define(api_map, closure, locals).first
-                return type.subtypes.first.qualify(api_map, bmeth.context.namespace)
-              end
-            else
-              yps = meth.docstring.tags(:yieldparam)
-              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
-                return ComplexType.try_parse(yps[index].types.first).self_to(chain.base.infer(api_map, closure, locals).namespace).qualify(api_map, meth.context.namespace)
-              end
-            end
-          end
-        end
-        ComplexType::UNDEFINED
-      end
-
-      # @param api_map [ApiMap]
-      # @return [ComplexType]
-      def typify_method_param api_map
-        meths = api_map.get_method_stack(closure.full_context.namespace, closure.name, scope: closure.scope)
-        # meths.shift # Ignore the first one
-        meths.each do |meth|
-          found = nil
-          params = meth.docstring.tags(:param) + see_reference(docstring, api_map)
-          params.each do |p|
-            next unless p.name == name
-            found = p
-            break
-          end
-          if found.nil? and !index.nil?
-            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
-          end
-          return ComplexType.try_parse(*found.types).qualify(api_map, meth.context.namespace) unless found.nil? || found.types.nil?
-        end
-        ComplexType::UNDEFINED
-      end
-
-      # @param heredoc [YARD::Docstring]
-      # @param api_map [ApiMap]
-      # @param skip [Array]
-      # @return [Array<YARD::Tags::Tag>]
-      def see_reference heredoc, api_map, skip = []
-        heredoc.ref_tags.each do |ref|
-          next unless ref.tag_name == 'param' && ref.owner
-          result = resolve_reference(ref.owner.to_s, api_map, skip)
-          return result unless result.nil?
-        end
-        []
-      end
-
-      # @param ref [String]
-      # @param api_map [ApiMap]
-      # @param skip [Array]
-      # @return [Array<YARD::Tags::Tag>, nil]
-      def resolve_reference ref, api_map, skip
-        return nil if skip.include?(ref)
-        skip.push ref
-        parts = ref.split(/[\.#]/)
-        if parts.first.empty?
-          path = "#{namespace}#{ref}"
-        else
-          fqns = api_map.qualify(parts.first, namespace)
-          return nil if fqns.nil?
-          path = fqns + ref[parts.first.length] + parts.last
-        end
-        pins = api_map.get_path_pins(path)
-        pins.each do |pin|
-          params = pin.docstring.tags(:param)
-          return params unless params.empty?
-        end
-        pins.each do |pin|
-          params = see_reference(pin.docstring, api_map, skip)
-          return params unless params.empty?
-        end
-        nil
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Parameter < LocalVariable
+      # @return [Symbol]
+      attr_reader :decl
+
+      # @return [String]
+      attr_reader :asgn_code
+
+      def initialize decl: :arg, asgn_code: nil, **splat
+        super(**splat)
+        @asgn_code = asgn_code
+        @decl = decl
+      end
+
+      def keyword?
+        [:kwarg, :kwoptarg].include?(decl)
+      end
+
+      def kwrestarg?
+        decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
+      end
+
+      def restarg?
+        decl == :restarg
+      end
+
+      def rest?
+        decl == :restarg || decl == :kwrestarg
+      end
+
+      def full
+        case decl
+        when :optarg
+          "#{name} = #{asgn_code}"
+        when :kwarg
+          "#{name}:"
+        when :kwoptarg
+          "#{name}: #{asgn_code}"
+        when :restarg
+          "*#{name}"
+        when :kwrestarg
+          "**#{name}"
+        when :block, :blockarg
+          "&#{name}"
+        else
+          name
+        end
+      end
+
+      def return_type
+        if @return_type.nil?
+          @return_type = ComplexType::UNDEFINED
+          found = param_tag
+          @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
+          if @return_type.undefined?
+            if decl == :restarg
+              @return_type = ComplexType.try_parse('Array')
+            elsif decl == :kwrestarg
+              @return_type = ComplexType.try_parse('Hash')
+            elsif decl == :blockarg
+              @return_type = ComplexType.try_parse('Proc')
+            end
+          end
+        end
+        super
+        @return_type
+      end
+
+      # The parameter's zero-based location in the block's signature.
+      #
+      # @return [Integer]
+      def index
+        closure.parameter_names.index(name)
+      end
+
+      # @param api_map [ApiMap]
+      def typify api_map
+        return return_type.qualify(api_map, closure.context.namespace) unless return_type.undefined?
+        closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
+      end
+
+      def documentation
+        tag = param_tag
+        return '' if tag.nil? || tag.text.nil?
+        tag.text
+      end
+
+      def try_merge! pin
+        return false unless super && closure == pin.closure
+        true
+      end
+
+      private
+
+      # @return [YARD::Tags::Tag]
+      def param_tag
+        found = nil
+        params = closure.docstring.tags(:param)
+        params.each do |p|
+          next unless p.name == name
+          found = p
+          break
+        end
+        if found.nil? and !index.nil?
+          found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+        end
+        found
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def typify_block_param api_map
+        if closure.is_a?(Pin::Block) && closure.receiver
+          chain = Parser.chain(closure.receiver, filename)
+          clip = api_map.clip_at(location.filename, location.range.start)
+          locals = clip.locals - [self]
+          meths = chain.define(api_map, closure, locals)
+          meths.each do |meth|
+            if meth.docstring.has_tag?(:yieldparam_single_parameter)
+              type = chain.base.infer(api_map, closure, locals)
+              if type.defined? && !type.subtypes.empty?
+                bmeth = chain.base.define(api_map, closure, locals).first
+                return type.subtypes.first.qualify(api_map, bmeth.context.namespace)
+              end
+            else
+              yps = meth.docstring.tags(:yieldparam)
+              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
+                return ComplexType.try_parse(yps[index].types.first).self_to(chain.base.infer(api_map, closure, locals).namespace).qualify(api_map, meth.context.namespace)
+              end
+            end
+          end
+        end
+        ComplexType::UNDEFINED
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def typify_method_param api_map
+        meths = api_map.get_method_stack(closure.full_context.namespace, closure.name, scope: closure.scope)
+        # meths.shift # Ignore the first one
+        meths.each do |meth|
+          found = nil
+          params = meth.docstring.tags(:param) + see_reference(docstring, api_map)
+          params.each do |p|
+            next unless p.name == name
+            found = p
+            break
+          end
+          if found.nil? and !index.nil?
+            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          end
+          return ComplexType.try_parse(*found.types).qualify(api_map, meth.context.namespace) unless found.nil? || found.types.nil?
+        end
+        ComplexType::UNDEFINED
+      end
+
+      # @param heredoc [YARD::Docstring]
+      # @param api_map [ApiMap]
+      # @param skip [Array]
+      # @return [Array<YARD::Tags::Tag>]
+      def see_reference heredoc, api_map, skip = []
+        heredoc.ref_tags.each do |ref|
+          next unless ref.tag_name == 'param' && ref.owner
+          result = resolve_reference(ref.owner.to_s, api_map, skip)
+          return result unless result.nil?
+        end
+        []
+      end
+
+      # @param ref [String]
+      # @param api_map [ApiMap]
+      # @param skip [Array]
+      # @return [Array<YARD::Tags::Tag>, nil]
+      def resolve_reference ref, api_map, skip
+        return nil if skip.include?(ref)
+        skip.push ref
+        parts = ref.split(/[\.#]/)
+        if parts.first.empty?
+          path = "#{namespace}#{ref}"
+        else
+          fqns = api_map.qualify(parts.first, namespace)
+          return nil if fqns.nil?
+          path = fqns + ref[parts.first.length] + parts.last
+        end
+        pins = api_map.get_path_pins(path)
+        pins.each do |pin|
+          params = pin.docstring.tags(:param)
+          return params unless params.empty?
+        end
+        pins.each do |pin|
+          params = see_reference(pin.docstring, api_map, skip)
+          return params unless params.empty?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/solargraph/pin/proxy_type.rb

@@ -1,29 +1,29 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class ProxyType < Base
-      # @param return_type [ComplexType]
-      def initialize return_type: ComplexType::UNDEFINED, **splat
-        super(**splat)
-        @return_type = return_type
-      end
-
-      def context
-        @return_type
-      end
-
-      # @param return_type [ComplexType]
-      # @return [ProxyType]
-      def self.anonymous return_type
-        parts = return_type.namespace.split('::')
-        namespace = parts[0..-2].join('::').to_s
-        name = parts.last.to_s
-        # ProxyType.new(nil, namespace, name, return_type)
-        ProxyType.new(
-          closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type
-        )
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class ProxyType < Base
+      # @param return_type [ComplexType]
+      def initialize return_type: ComplexType::UNDEFINED, **splat
+        super(**splat)
+        @return_type = return_type
+      end
+
+      def context
+        @return_type
+      end
+
+      # @param return_type [ComplexType]
+      # @return [ProxyType]
+      def self.anonymous return_type
+        parts = return_type.namespace.split('::')
+        namespace = parts[0..-2].join('::').to_s
+        name = parts.last.to_s
+        # ProxyType.new(nil, namespace, name, return_type)
+        ProxyType.new(
+          closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type
+        )
+      end
+    end
+  end
+end