solargraph 0.47.2 → 0.49.0

data/lib/solargraph/language_server/message/text_document/signature_help.rb

@@ -9,13 +9,8 @@ module Solargraph
             line = params['position']['line']
             col = params['position']['character']
             suggestions = host.signatures_at(params['textDocument']['uri'], line, col)
-            info = []
-            suggestions.each do |pin|
-              info.concat pin.overloads.map(&:signature_help)
-              info.push pin.signature_help
-            end
             set_result({
-              signatures: info
+              signatures: suggestions.flat_map { |pin| pin.signature_help }
             })
           rescue FileNotFoundError => e
             Logging.logger.warn "[#{e.class}] #{e.message}"

data/lib/solargraph/language_server/message/workspace/did_change_watched_files.rb

@@ -10,22 +10,29 @@ module Solargraph::LanguageServer::Message::Workspace
 
     def process
       need_catalog = false
+      to_create = []
+      to_delete = []
+
       # @param change [Hash]
       params['changes'].each do |change|
         if change['type'] == CREATED
-          host.create change['uri']
+          to_create << change['uri']
           need_catalog = true
         elsif change['type'] == CHANGED
           next if host.open?(change['uri'])
-          host.create change['uri']
+          to_create << change['uri']
           need_catalog = true
         elsif change['type'] == DELETED
-          host.delete change['uri']
+          to_delete << change['uri']
           need_catalog = true
         else
           set_error Solargraph::LanguageServer::ErrorCodes::INVALID_PARAMS, "Unknown change type ##{change['type']} for #{uri_to_file(change['uri'])}"
         end
       end
+
+      host.create *to_create
+      host.delete *to_delete
+
       # Force host to catalog libraries after file changes (see castwide/solargraph#139)
       host.catalog if need_catalog
     end

data/lib/solargraph/library.rb

@@ -106,36 +106,37 @@ module Solargraph
       result
     end
 
-    # Create a file source from a file on disk. The file is ignored if it is
+    # Create file sources from files on disk. A file is ignored if it is
     # neither open in the library nor included in the workspace.
     #
-    # @param filename [String]
-    # @return [Boolean] True if the file was added to the workspace.
-    def create_from_disk filename
+    # @param filenames [Array<String>]
+    # @return [Boolean] True if at least one file was added to the workspace.
+    def create_from_disk *filenames
       result = false
       mutex.synchronize do
-        next if File.directory?(filename) || !File.exist?(filename)
-        next unless contain?(filename) || open?(filename) || workspace.would_merge?(filename)
-        source = Solargraph::Source.load_string(File.read(filename), filename)
-        workspace.merge(source)
-        maybe_map source
-        result = true
+        sources = filenames
+          .reject { |filename| File.directory?(filename) || !File.exist?(filename) }
+          .map { |filename| Solargraph::Source.load_string(File.read(filename), filename) }
+        result = workspace.merge(*sources)
+        sources.each { |source| maybe_map source }
       end
       result
     end
 
-    # Delete a file from the library. Deleting a file will make it unavailable
+    # Delete files from the library. Deleting a file will make it unavailable
     # for checkout and optionally remove it from the workspace unless the
     # workspace configuration determines that it should still exist.
     #
-    # @param filename [String]
-    # @return [Boolean] True if the file was deleted
-    def delete filename
-      detach filename
+    # @param filenames [Array<String>]
+    # @return [Boolean] True if any file was deleted
+    def delete *filenames
       result = false
-      mutex.synchronize do
-        result = workspace.remove(filename)
-        @synchronized = !result if synchronized?
+      filenames.each do |filename|
+        detach filename
+        mutex.synchronize do
+          result ||= workspace.remove(filename)
+          @synchronized = !result if synchronized?
+        end
       end
       result
     end
@@ -267,7 +268,7 @@ module Solargraph
         next unless source_map_hash.key?(full)
         return Location.new(full, Solargraph::Range.from_to(0, 0, 0, 0))
       end
-      api_map.yard_map.require_reference(pin.name)
+      # api_map.yard_map.require_reference(pin.name)
     rescue FileNotFoundError
       nil
     end
@@ -522,7 +523,7 @@ module Solargraph
       return unless source
       return unless @current == source || workspace.has_file?(source.filename)
       if source_map_hash.key?(source.filename)
-        return if source_map_hash[source.filename].code == source.code && 
+        return if source_map_hash[source.filename].code == source.code &&
           source_map_hash[source.filename].source.synchronized? &&
           source.synchronized?
         if source.synchronized?

data/lib/solargraph/parser/legacy/node_processors/casgn_node.rb

@@ -8,16 +8,26 @@ module Solargraph
           include Legacy::NodeMethods
 
           def process
-            here = get_node_start_position(node)
             pins.push Solargraph::Pin::Constant.new(
               location: get_node_location(node),
               closure: region.closure,
-              name: node.children[1].to_s,
+              name: const_name,
               comments: comments_for(node),
               assignment: node.children[2]
             )
             process_children
           end
+
+          private
+
+          # @return [String]
+          def const_name
+            if node.children[0]
+              Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+            else
+              node.children[1].to_s
+            end
+          end
         end
       end
     end

data/lib/solargraph/parser/legacy/node_processors/sclass_node.rb

@@ -6,11 +6,32 @@ module Solargraph
       module NodeProcessors
         class SclassNode < Parser::NodeProcessor::Base
           def process
-            # @todo Temporarily skipping remote metaclasses
-            return unless node.children[0].is_a?(AST::Node) && node.children[0].type == :self
+            sclass = node.children[0]
+            if sclass.is_a?(AST::Node) && sclass.type == :self
+              closure = region.closure
+            elsif sclass.is_a?(AST::Node) && sclass.type == :casgn
+              names = [region.closure.namespace, region.closure.name]
+              if sclass.children[0].nil? && names.last != sclass.children[1].to_s
+                names << sclass.children[1].to_s
+              else
+                names.concat [NodeMethods.unpack_name(sclass.children[0]), sclass.children[1].to_s]
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            elsif sclass.is_a?(AST::Node) && sclass.type == :const
+              names = [region.closure.namespace, region.closure.name]
+              also = NodeMethods.unpack_name(sclass)
+              if also != region.closure.name
+                names << also
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            else
+              return
+            end
             pins.push Solargraph::Pin::Singleton.new(
               location: get_node_location(node),
-              closure: region.closure
+              closure: closure
             )
             process_children region.update(visibility: :public, scope: :class, closure: pins.last)
           end

data/lib/solargraph/parser/rubyvm/class_methods.rb

@@ -1,4 +1,5 @@
 require 'solargraph/parser/rubyvm/node_processors'
+require 'solargraph/parser/rubyvm/node_wrapper'
 
 module Solargraph
   module Parser
@@ -7,8 +8,10 @@ module Solargraph
         # @param code [String]
         # @param filename [String]
         # @return [Array(Parser::AST::Node, Array<Parser::Source::Comment>)]
+        # @sg-ignore
         def parse_with_comments code, filename = nil
           node = RubyVM::AbstractSyntaxTree.parse(code).children[2]
+          node &&= RubyVM::AbstractSyntaxTree::NodeWrapper.from(node, code.lines)
           comments = CommentRipper.new(code).parse
           [node, comments]
         rescue ::SyntaxError => e
@@ -19,8 +22,10 @@ module Solargraph
         # @param filename [String, nil]
         # @param line [Integer]
         # @return [Parser::AST::Node]
+        # @sg-ignore
         def parse code, filename = nil, line = 0
-          RubyVM::AbstractSyntaxTree.parse(code).children[2]
+          node = RubyVM::AbstractSyntaxTree.parse(code).children[2]
+          node and RubyVM::AbstractSyntaxTree::NodeWrapper.from(node, code.lines)
         rescue ::SyntaxError => e
           raise Parser::SyntaxError, e.message
         end

data/lib/solargraph/parser/rubyvm/node_processors/casgn_node.rb

@@ -9,12 +9,23 @@ module Solargraph
             pins.push Solargraph::Pin::Constant.new(
               location: get_node_location(node),
               closure: region.closure,
-              name: node.children[0].to_s,
+              name: const_name,
               comments: comments_for(node),
-              assignment: node.children[1]
+              assignment: node.children[2] || node.children[1]
             )
             process_children
           end
+
+          private
+
+          # @return [String]
+          def const_name
+            if Parser.is_ast_node?(node.children[0])
+              Parser::NodeMethods.unpack_name(node.children[0])
+            else
+              node.children[0].to_s
+            end
+          end
         end
       end
     end

data/lib/solargraph/parser/rubyvm/node_processors/def_node.rb

@@ -6,6 +6,8 @@ module Solargraph
       module NodeProcessors
         class DefNode < Parser::NodeProcessor::Base
           def process
+            anon_splat = node_has_anon_splat?
+
             methpin = Solargraph::Pin::Method.new(
               location: get_node_location(node),
               closure: region.closure,
@@ -13,17 +15,19 @@ module Solargraph
               comments: comments_for(node),
               scope: region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance),
               visibility: region.visibility,
-              node: node
+              node: node,
+              anon_splat: anon_splat
             )
-            if methpin.name == 'initialize' and methpin.scope == :instance
+            if methpin.name == 'initialize' && methpin.scope == :instance
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,
                 name: 'new',
                 comments: methpin.comments,
                 scope: :class,
-                parameters: methpin.parameters
-              )
+                parameters: methpin.parameters,
+                anon_splat: anon_splat
+                )
               # @todo Smelly instance variable access.
               pins.last.instance_variable_set(:@return_type, ComplexType::SELF)
               pins.push methpin
@@ -39,8 +43,9 @@ module Solargraph
                 scope: :class,
                 visibility: :public,
                 parameters: methpin.parameters,
-                node: methpin.node
-              )
+                node: methpin.node,
+                anon_splat: anon_splat
+                )
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,
@@ -49,13 +54,20 @@ module Solargraph
                 scope: :instance,
                 visibility: :private,
                 parameters: methpin.parameters,
-                node: methpin.node
-              )
+                node: methpin.node,
+                anon_splat: anon_splat
+                )
             else
               pins.push methpin
             end
             process_children region.update(closure: methpin, scope: methpin.scope)
           end
+
+          private
+
+          def node_has_anon_splat?
+            node.children[1]&.children&.first == [nil]
+          end
         end
       end
     end

data/lib/solargraph/parser/rubyvm/node_processors/defs_node.rb

@@ -11,6 +11,8 @@ module Solargraph
             s_visi = region.visibility
             s_visi = :public if region.scope != :class
             loc = get_node_location(node)
+            anon_splat = node_has_anon_splat?
+
             if node.children[0].is_a?(RubyVM::AbstractSyntaxTree::Node) && node.children[0].type == :SELF
               closure = region.closure
             else
@@ -26,7 +28,8 @@ module Solargraph
                 comments: comments_for(node),
                 scope: :class,
                 visibility: :public,
-                node: node
+                node: node,
+                anon_splat: anon_splat
               )
               pins.push Solargraph::Pin::Method.new(
                 location: loc,
@@ -35,7 +38,8 @@ module Solargraph
                 comments: comments_for(node),
                 scope: :instance,
                 visibility: :private,
-                node: node
+                node: node,
+                anon_splat: anon_splat
               )
             else
               pins.push Solargraph::Pin::Method.new(
@@ -45,11 +49,18 @@ module Solargraph
                 comments: comments_for(node),
                 scope: :class,
                 visibility: s_visi,
-                node: node
+                node: node,
+                anon_splat: anon_splat
               )
             end
             process_children region.update(closure: pins.last, scope: :class)
           end
+
+          private
+
+          def node_has_anon_splat?
+            node.children[2]&.children&.first == [nil]
+          end
         end
       end
     end

data/lib/solargraph/parser/rubyvm/node_processors/sclass_node.rb

@@ -6,11 +6,22 @@ module Solargraph
       module NodeProcessors
         class SclassNode < Parser::NodeProcessor::Base
           def process
-            # @todo Temporarily skipping remote metaclasses
-            return unless node.children[0].is_a?(RubyVM::AbstractSyntaxTree::Node) && node.children[0].type == :SELF
+            sclass = node.children[0]
+            if sclass.is_a?(RubyVM::AbstractSyntaxTree::Node) && sclass.type == :SELF
+              closure = region.closure
+            elsif sclass.is_a?(RubyVM::AbstractSyntaxTree::Node) && %i[CDECL CONST].include?(sclass.type)
+              names = [region.closure.namespace, region.closure.name]
+              if names.last != sclass.children[0].to_s
+                names << sclass.children[0].to_s
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            else
+              return
+            end
             pins.push Solargraph::Pin::Singleton.new(
               location: get_node_location(node),
-              closure: region.closure
+              closure: closure
             )
             process_children region.update(visibility: :public, scope: :class, closure: pins.last)
           end

data/lib/solargraph/parser/rubyvm/node_processors/send_node.rb

@@ -226,8 +226,10 @@ module Solargraph
 
           # @return [void]
           def process_private_constant
-            return unless Parser.is_ast_node?(node.children.last)
-            node.children.last.children[0..-2].each do |child|
+            arr = node.children[1]
+            return unless Parser.is_ast_node?(arr) && [:ARRAY, :LIST].include?(arr.type)
+
+            arr.children.compact.each do |child|
               if [:LIT, :STR].include?(child.type)
                 cn = child.children[0].to_s
                 ref = pins.select{|p| [Solargraph::Pin::Namespace, Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn}.first

data/lib/solargraph/parser/rubyvm/node_wrapper.rb

@@ -0,0 +1,47 @@
+require 'delegate'
+
+module RubyVM::AbstractSyntaxTree
+  # Wrapper for RubyVM::AbstractSyntaxTree::Node. for return character based column
+  class NodeWrapper < SimpleDelegator
+    attr_reader :code
+    # @param node [RubyVM::AbstractSyntaxTree::Node] wrapped node to return character based column
+    # @param code [Array<String>] source code lines for generated this node
+    def initialize(node, code)
+      @code = code
+      super(node)
+    end
+
+    def self.from(node, code)
+      return node unless node.is_a?(RubyVM::AbstractSyntaxTree::Node) and !node.kind_of?(SimpleDelegator)
+
+      new(node, code)
+    end
+
+    def is_a?(type)
+      __getobj__.is_a?(type) || super.is_a?(type)
+    end
+
+    def class
+      __getobj__.class
+    end
+
+
+    def first_column
+      @first_column ||= begin
+        line = @code[__getobj__.first_lineno - 1] || ""
+        line.byteslice(0, __getobj__.first_column).length
+      end
+    end
+
+    def last_column
+      @last_column ||= begin
+        line = @code[__getobj__.last_lineno - 1] || ""
+        line.byteslice(0, __getobj__.last_column).length
+      end
+    end
+
+    def children
+      @children ||= __getobj__.children.map do |node| NodeWrapper.from(node, @code) end
+    end
+  end
+end

data/lib/solargraph/pin/base.rb

@@ -21,9 +21,12 @@ module Solargraph
       # @return [String]
       attr_reader :path
 
-      # @param location [Solargraph::Location]
+      # @return [::Symbol]
+      attr_accessor :source
+
+      # @param location [Solargraph::Location, nil]
       # @param kind [Integer]
-      # @param closure [Solargraph::Pin::Closure]
+      # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
       def initialize location: nil, closure: nil, name: '', comments: ''

data/lib/solargraph/pin/conversions.rb

@@ -34,12 +34,9 @@ module Solargraph
         end
       end
 
-      # @return [Hash]
+      # @return [Array<Hash>]
       def signature_help
-        @signature_help ||= {
-          label: name + '(' + parameters.map(&:full).join(', ') + ')',
-          documentation: documentation
-        }
+        []
       end
 
       # @return [String]
@@ -47,7 +44,6 @@ module Solargraph
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
         detail = String.new
-        detail += "(#{parameters.map(&:full).join(', ')}) " unless !is_a?(Pin::Method) || parameters.empty?
         detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
         detail.strip!
         return nil if detail.empty?

data/lib/solargraph/pin/method.rb

@@ -18,13 +18,18 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, **splat
+      # @param parameters [Array<Pin::Parameter>]
+      # @param node [Parser::AST::Node, RubyVM::AbstractSyntaxTree::Node]
+      # @param attribute [Boolean]
+      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, signatures: nil, anon_splat: false, **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
         @parameters = parameters
         @node = node
         @attribute = attribute
+        @signatures = signatures
+        @anon_splat = anon_splat
       end
 
       # @return [Array<String>]
@@ -41,7 +46,45 @@ module Solargraph
       end
 
       def return_type
-        @return_type ||= generate_complex_type
+        @return_type ||= ComplexType.try_parse(*signatures.map(&:return_type).map(&:to_s))
+      end
+
+      # @return [Array<Signature>]
+      def signatures
+        @signatures ||= begin
+          top_type = generate_complex_type
+          result = []
+          result.push Signature.new(parameters, top_type) if top_type.defined?
+          result.concat(overloads.map { |meth| Signature.new(meth.parameters, meth.return_type) })
+          result.push Signature.new(parameters, top_type) if result.empty?
+          result
+        end
+      end
+
+      # @return [String]
+      def detail
+        # This property is not cached in an instance variable because it can
+        # change when pins get proxied.
+        detail = String.new
+        detail += if signatures.length > 1
+          "(*) "
+        else
+          "(#{signatures.first.parameters.map(&:full).join(', ')}) " unless signatures.first.parameters.empty?
+        end.to_s
+        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
+        detail.strip!
+        return nil if detail.empty?
+        detail
+      end
+
+      # @return [Array<Hash>]
+      def signature_help
+        @signature_help ||= signatures.map do |sig|
+          {
+            label: name + '(' + sig.parameters.map(&:full).join(', ') + ')',
+            documentation: documentation
+          }
+        end
       end
 
       def path
@@ -119,27 +162,60 @@ module Solargraph
       # @return [Array<Pin::Method>]
       def overloads
         @overloads ||= docstring.tags(:overload).map do |tag|
-          Solargraph::Pin::Method.new(
-            name: name,
-            closure: self,
-            # args: tag.parameters.map(&:first),
-            parameters: tag.parameters.map do |src|
+          Pin::Signature.new(
+            tag.parameters.map do |src|
+              name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
                 location: location,
                 closure: self,
                 comments: tag.docstring.all.to_s,
-                name: src.first,
+                name: name,
+                decl: decl,
                 presence: location ? location.range : nil,
-                decl: :arg
+                return_type: param_type_from_name(tag, src.first)
               )
             end,
-            comments: tag.docstring.all.to_s
+            ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
           )
         end
+        @overloads
+      end
+
+      def anon_splat?
+        @anon_splat
       end
 
       private
 
+      def select_decl name, asgn
+        if name.start_with?('**')
+          :kwrestarg
+        elsif name.start_with?('*')
+          :restarg
+        elsif name.start_with?('&')
+          :blockarg
+        elsif name.end_with?(':') && asgn
+          :kwoptarg
+        elsif name.end_with?(':')
+          :kwarg
+        elsif asgn
+          :optarg
+        else
+          :arg
+        end
+      end
+
+      def clean_param name
+        name.gsub(/[*&:]/, '')
+      end
+
+      # @param tag [YARD::Tags::OverloadTag]
+      def param_type_from_name(tag, name)
+        param = tag.tags(:param).select { |t| t.name == name }.first
+        return ComplexType::UNDEFINED unless param
+        ComplexType.try_parse(*param.types)
+      end
+
       # @return [ComplexType]
       def generate_complex_type
         tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
@@ -240,6 +316,20 @@ module Solargraph
         return ComplexType::UNDEFINED if types.empty?
         ComplexType.try_parse(*types.map(&:tag).uniq)
       end
+
+      # When YARD parses an overload tag, it includes rest modifiers in the parameters names.
+      #
+      # @param arg [String]
+      # @return [Array(String, Symbol)]
+      def parse_overload_param(name)
+        if name.start_with?('**')
+          [name[2..-1], :kwrestarg]
+        elsif name.start_with?('*')
+          [name[1..-1], :restarg]
+        else
+          [name, :arg]
+        end
+      end
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -9,10 +9,12 @@ module Solargraph
       # @return [::Symbol] :class or :module
       attr_reader :type
 
+      attr_reader :parameters
+
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
       # @param gates [Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], **splat
+      def initialize type: :class, visibility: :public, gates: [''], parameters: [], **splat
         # super(location, namespace, name, comments)
         super(**splat)
         @type = type
@@ -36,6 +38,7 @@ module Solargraph
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
           @context = nil
         end
+        @parameters = parameters
       end
 
       def namespace