solargraph 0.39.14 → 0.40.1

data/lib/solargraph/pin/method.rb

@@ -2,18 +2,29 @@
 
 module Solargraph
   module Pin
-    class Method < BaseMethod
+    # The base class for method and attribute pins.
+    #
+    class Method < Closure
       include Solargraph::Parser::NodeMethods
 
       # @return [Array<Pin::Parameter>]
       attr_reader :parameters
 
-      # @param args [Array<String>]
-      # @param node [Parser::AST::Node, nil]
-      def initialize parameters: [], node: nil, **splat
+      # @return [::Symbol] :public, :private, or :protected
+      attr_reader :visibility
+
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @param visibility [::Symbol] :public, :protected, or :private
+      # @param explicit [Boolean]
+      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, **splat
         super(**splat)
+        @visibility = visibility
+        @explicit = explicit
         @parameters = parameters
         @node = node
+        @attribute = attribute
       end
 
       # @return [Array<String>]
@@ -22,11 +33,70 @@ module Solargraph
       end
 
       def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::METHOD
+        attribute? ? Solargraph::LanguageServer::CompletionItemKinds::PROPERTY : Solargraph::LanguageServer::CompletionItemKinds::METHOD
       end
 
       def symbol_kind
-        LanguageServer::SymbolKinds::METHOD
+        attribute? ? Solargraph::LanguageServer::SymbolKinds::PROPERTY : LanguageServer::SymbolKinds::METHOD
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def path
+        @path ||= "#{namespace}#{(scope == :instance ? '#' : '.')}#{name}"
+      end
+
+      def typify api_map
+        decl = super
+        return decl unless decl.undefined?
+        type = see_reference(api_map) || typify_from_super(api_map)
+        return type.qualify(api_map, namespace) unless type.nil?
+        name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
+      end
+
+      def documentation
+        if @documentation.nil?
+          @documentation ||= super || ''
+          param_tags = docstring.tags(:param)
+          unless param_tags.nil? or param_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Params:\n"
+            lines = []
+            param_tags.each do |p|
+              l = "* #{p.name}"
+              l += " [#{escape_brackets(p.types.join(', '))}]" unless p.types.nil? or p.types.empty?
+              l += " #{p.text}"
+              lines.push l
+            end
+            @documentation += lines.join("\n")
+          end
+          return_tags = docstring.tags(:return)
+          unless return_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Returns:\n"
+            lines = []
+            return_tags.each do |r|
+              l = "*"
+              l += " [#{escape_brackets(r.types.join(', '))}]" unless r.types.nil? or r.types.empty?
+              l += " #{r.text}"
+              lines.push l
+            end
+            @documentation += lines.join("\n")
+          end
+          @documentation += "\n\n" unless @documentation.empty?
+          @documentation += "Visibility: #{visibility}"
+        end
+        @documentation.to_s
+      end
+
+      def explicit?
+        @explicit
+      end
+
+      def attribute?
+        @attribute
       end
 
       def nearly? other
@@ -37,7 +107,7 @@ module Solargraph
       end
 
       def probe api_map
-        infer_from_return_nodes(api_map)
+        attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
       end
 
       def try_merge! pin
@@ -70,6 +140,57 @@ module Solargraph
 
       private
 
+      # @return [ComplexType]
+      def generate_complex_type
+        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
+        return ComplexType::UNDEFINED if tags.empty?
+        ComplexType.try_parse *tags
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def see_reference api_map
+        docstring.ref_tags.each do |ref|
+          next unless ref.tag_name == 'return' && ref.owner
+          result = resolve_reference(ref.owner.to_s, api_map)
+          return result unless result.nil?
+        end
+        match = comments.match(/^[ \t]*\(see (.*)\)/m)
+        return nil if match.nil?
+        resolve_reference match[1], api_map
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def typify_from_super api_map
+        stack = api_map.get_method_stack(namespace, name, scope: scope).reject { |pin| pin.path == path }
+        return nil if stack.empty?
+        stack.each do |pin|
+          return pin.return_type unless pin.return_type.undefined?
+        end
+        nil
+      end
+
+      # @param ref [String]
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def resolve_reference ref, api_map
+        parts = ref.split(/[\.#]/)
+        if parts.first.empty? || parts.one?
+          path = "#{namespace}#{ref}"
+        else
+          fqns = api_map.qualify(parts.first, namespace)
+          return ComplexType::UNDEFINED if fqns.nil?
+          path = fqns + ref[parts.first.length] + parts.last
+        end
+        pins = api_map.get_path_pins(path)
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          return type unless type.undefined?
+        end
+        nil
+      end
+
       # @return [Parser::AST::Node, nil]
       def method_body_node
         return nil if node.nil?
@@ -106,6 +227,19 @@ module Solargraph
         return ComplexType::UNDEFINED if result.empty?
         ComplexType.try_parse(*result.map(&:tag).uniq)
       end
+
+      def infer_from_iv api_map
+        types = []
+        varname = "@#{name.gsub(/=$/, '')}"
+        pins = api_map.get_instance_variable_pins(binder.namespace, binder.scope).select { |iv| iv.name == varname }
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          type = pin.probe(api_map) if type.undefined?
+          types.push type if type.defined?
+        end
+        return ComplexType::UNDEFINED if types.empty?
+        ComplexType.try_parse(*types.map(&:tag).uniq)
+      end
     end
   end
 end

data/lib/solargraph/pin/method_alias.rb

@@ -6,7 +6,7 @@ module Solargraph
     # examples that defer mapping are aliases for superclass methods or
     # methods from included modules.
     #
-    class MethodAlias < BaseMethod
+    class MethodAlias < Method
       # @return [::Symbol]
       attr_reader :scope
 

data/lib/solargraph/position.rb

@@ -40,20 +40,8 @@ module Solargraph
     # @param position [Position]
     # @return [Integer]
     def self.to_offset text, position
-      result = 0
-      feed = 0
-      line = position.line
-      column = position.character
-      text.lines.each do |l|
-        line_length = l.length
-        if feed == line
-          result += column
-          break
-        end
-        result += line_length
-        feed += 1
-      end
-      result
+      return 0 if text.empty?
+      text.lines[0...position.line].sum(&:length) + position.character
     end
 
     # Get a numeric offset for the specified text and a position identified

data/lib/solargraph/shell.rb

@@ -153,7 +153,7 @@ module Solargraph
         probcount += problems.length
       end
       puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
-      exit 1 if probcount.positive?
+      exit 1 if probcount > 0
     end
 
     desc 'scan', 'Test the workspace for problems'

data/lib/solargraph/source.rb

@@ -284,7 +284,7 @@ module Solargraph
 
     FOLDING_NODE_TYPES = if Parser.rubyvm?
       %i[
-        CLASS SCLASS MODULE DEFN DEFS IF WHILE UNLESS ITER STR
+        CLASS SCLASS MODULE DEFN DEFS IF WHILE UNLESS ITER STR HASH ARRAY LIST
       ].freeze
     else
       %i[
@@ -345,18 +345,22 @@ module Solargraph
 
     # @param top [Parser::AST::Node]
     # @param result [Array<Range>]
+    # @param parent [Symbol]
     # @return [void]
-    def inner_folding_ranges top, result = []
+    def inner_folding_ranges top, result = [], parent = nil
       # return unless top.is_a?(::Parser::AST::Node)
       return unless Parser.is_ast_node?(top)
       if FOLDING_NODE_TYPES.include?(top.type)
-        range = Range.from_node(top)
-        if result.empty? || range.start.line > result.last.start.line
-          result.push range unless range.ending.line - range.start.line < 2
+        # @todo Smelly exception for hash's first-level array in RubyVM
+        unless [:ARRAY, :LIST].include?(top.type) && parent == :HASH
+          range = Range.from_node(top)
+          if result.empty? || range.start.line > result.last.start.line
+            result.push range unless range.ending.line - range.start.line < 2
+          end
         end
       end
       top.children.each do |child|
-        inner_folding_ranges(child, result)
+        inner_folding_ranges(child, result, top.type)
       end
     end
 

data/lib/solargraph/source/chain.rb

@@ -110,18 +110,21 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def infer_first_defined pins, context, api_map
-        type = ComplexType::UNDEFINED
+        possibles = []
         pins.each do |pin|
           # Avoid infinite recursion
           next if @@inference_stack.include?(pin.identity)
           @@inference_stack.push pin.identity
           type = pin.typify(api_map)
           @@inference_stack.pop
-          break if type.defined?
+          if type.defined?
+            possibles.push type
+            break if pin.is_a?(Pin::Method)
+          end
         end
-        if type.undefined?
+        if possibles.empty?
           # Limit method inference recursion
-          return type if @@inference_depth >= 10 && pins.first.is_a?(Pin::BaseMethod)
+          return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
           @@inference_depth += 1
           pins.each do |pin|
             # Avoid infinite recursion
@@ -129,10 +132,20 @@ module Solargraph
             @@inference_stack.push pin.identity
             type = pin.probe(api_map)
             @@inference_stack.pop
-            break if type.defined?
+            if type.defined?
+              possibles.push type
+              break if pin.is_a?(Pin::Method)
+            end
           end
           @@inference_depth -= 1
         end
+        return ComplexType::UNDEFINED if possibles.empty?
+        type = if possibles.length > 1
+          sorted = possibles.map { |t| t.rooted? ? "::#{t}" : t.to_s }.sort { |a, _| a == 'nil' ? 1 : 0 }
+          ComplexType.parse(*sorted)
+        else
+          possibles.first
+        end
         return type if context.nil? || context.return_type.undefined?
         type.self_to(context.return_type.namespace)
       end

data/lib/solargraph/source_map.rb

@@ -30,7 +30,7 @@ module Solargraph
       @source = source.dup
       @pins = pins
       @locals = locals
-      environ.merge Convention.for(source)
+      environ.merge Convention.for_local(self) unless filename.nil?
       @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
       @pin_select_cache = {}
     end
@@ -168,6 +168,9 @@ module Solargraph
       position = Position.new(line, character)
       found = nil
       pins.each do |pin|
+        # @todo Attribute pins should not be treated like closures, but
+        #   there's probably a better way to handle it
+        next if pin.is_a?(Pin::Method) && pin.attribute?
         found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
         break if pin.location.range.start.line > line
       end

data/lib/solargraph/source_map/clip.rb

@@ -149,7 +149,7 @@ module Solargraph
         frag_start = cursor.start_of_word.to_s.downcase
         filtered = result.uniq(&:name).select { |s|
           s.name.downcase.start_with?(frag_start) &&
-            (!s.is_a?(Pin::BaseMethod) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
+            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
         }
         Completion.new(filtered, cursor.range)
       end
@@ -212,7 +212,8 @@ module Solargraph
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
             result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
-            result.concat ApiMap.keywords
+            # result.concat ApiMap.keywords
+            result.concat api_map.keyword_pins
             result.concat yielded_self_pins
           end
         end

data/lib/solargraph/source_map/mapper.rb

@@ -126,27 +126,31 @@ module Solargraph
           namespace = closure_at(source_position)
           t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
           if t.nil? || t.include?('r')
-            pins.push Solargraph::Pin::Attribute.new(
+            pins.push Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: directive.tag.name,
               comments: docstring.all.to_s,
-              access: :reader,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
-              explicit: false
+              explicit: false,
+              attribute: true
             )
           end
           if t.nil? || t.include?('w')
-            pins.push Solargraph::Pin::Attribute.new(
+            pins.push Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: "#{directive.tag.name}=",
               comments: docstring.all.to_s,
-              access: :writer,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
-              visibility: :public
+              visibility: :public,
+              attribute: true
             )
+            pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            if pins.last.return_type.defined?
+              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+            end
           end
         when 'parse'
           begin

data/lib/solargraph/type_checker.rb

@@ -73,15 +73,15 @@ module Solargraph
     # @return [Array<Problem>]
     def method_tag_problems
       result = []
-      # @param pin [Pin::BaseMethod]
-      source_map.pins_by_class(Pin::BaseMethod).each do |pin|
+      # @param pin [Pin::Method]
+      source_map.pins_by_class(Pin::Method).each do |pin|
         result.concat method_return_type_problems_for(pin)
         result.concat method_param_type_problems_for(pin)
       end
       result
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     # @return [Array<Problem>]
     def method_return_type_problems_for pin
       result = []
@@ -115,7 +115,7 @@ module Solargraph
       pin.location && source_map.source.comment_at?(pin.location.range.ending)
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     # @return [Array<Problem>]
     def method_param_type_problems_for pin
       stack = api_map.get_method_stack(pin.namespace, pin.name, scope: pin.scope)
@@ -147,14 +147,12 @@ module Solargraph
       result = []
       all_variables.each do |pin|
         if pin.return_type.defined?
-          # @todo Somwhere in here we still need to determine if the variable is defined by an external call
           declared = pin.typify(api_map)
           if declared.defined?
             if rules.validate_tags?
               inferred = pin.probe(api_map)
               if inferred.undefined?
                 next if rules.ignore_all_undefined?
-                # next unless internal?(pin) # @todo This might be redundant for variables
                 if declared_externally?(pin)
                   ignored_pins.push pin
                 else
@@ -172,7 +170,6 @@ module Solargraph
             result.push Problem.new(pin.location, "Unresolved type #{pin.return_type} for variable #{pin.name}", pin: pin)
           end
         else
-          # @todo Check if the variable is defined by an external call
           inferred = pin.probe(api_map)
           if inferred.undefined? && declared_externally?(pin)
             ignored_pins.push pin
@@ -227,7 +224,7 @@ module Solargraph
             base = base.base
           end
           closest = found.typify(api_map) if found
-          if !found || closest.defined? || internal?(found)
+          if !found || (closest.defined? && internal_or_core?(found))
             unless ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
               @marked_ranges.push rng
@@ -244,8 +241,8 @@ module Solargraph
       base = chain
       until base.links.length == 1 && base.undefined?
         pins = base.define(api_map, block_pin, locals)
-        if pins.first.is_a?(Pin::BaseMethod)
-          # @type [Pin::BaseMethod]
+        if pins.first.is_a?(Pin::Method)
+          # @type [Pin::Method]
           pin = pins.first
           ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
             arity_problems_for(pin, fake_args_for(block_pin), location)
@@ -313,7 +310,6 @@ module Solargraph
             end
           else
             if par.decl == :kwarg
-              # @todo Problem: missing required keyword argument
               result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
             end
           end
@@ -360,9 +356,14 @@ module Solargraph
 
     # @param pin [Pin::Base]
     def internal? pin
+      return false if pin.nil?
       pin.location && api_map.bundled?(pin.location.filename)
     end
 
+    def internal_or_core? pin
+      internal?(pin) || api_map.yard_map.core_pins.include?(pin) || api_map.yard_map.stdlib_pins.include?(pin)
+    end
+
     # @param pin [Pin::Base]
     def external? pin
       !internal? pin
@@ -395,7 +396,7 @@ module Solargraph
       true
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     def arity_problems_for(pin, arguments, location)
       return [] unless pin.explicit?
       return [] if pin.parameters.empty? && arguments.empty?
@@ -410,29 +411,29 @@ module Solargraph
       if unchecked.empty? && pin.parameters.any? { |param| param.decl == :kwarg }
         return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
       end
+      settled_kwargs = 0
       unless unchecked.empty?
         kwargs = convert_hash(unchecked.last.node)
-        # unless kwargs.empty?
-          if pin.parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
-            if kwargs.empty?
-              add_params += 1
-            else
-              unchecked.pop
-              pin.parameters.each do |param|
-                next unless param.keyword?
-                if kwargs.key?(param.name.to_sym)
-                  kwargs.delete param.name.to_sym
-                elsif param.decl == :kwarg
-                  return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
-                end
-              end
-              kwargs.clear if pin.parameters.any?(&:kwrestarg?)
-              unless kwargs.empty?
-                return [Problem.new(location, "Unrecognized keyword argument #{kwargs.keys.first} to #{pin.path}")]
+        if pin.parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
+          if kwargs.empty?
+            add_params += 1
+          else
+            unchecked.pop
+            pin.parameters.each do |param|
+              next unless param.keyword?
+              if kwargs.key?(param.name.to_sym)
+                kwargs.delete param.name.to_sym
+                settled_kwargs += 1
+              elsif param.decl == :kwarg
+                return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
               end
             end
+            kwargs.clear if pin.parameters.any?(&:kwrestarg?)
+            unless kwargs.empty?
+              return [Problem.new(location, "Unrecognized keyword argument #{kwargs.keys.first} to #{pin.path}")]
+            end
           end
-        # end
+        end
       end
       req = required_param_count(pin)
       if req + add_params < unchecked.length
@@ -443,23 +444,18 @@ module Solargraph
           return []
         end
         return [Problem.new(location, "Too many arguments to #{pin.path}")]
-      elsif unchecked.length < req && (arguments.empty? || !arguments.last.splat?)
+      elsif unchecked.length < req - settled_kwargs && (arguments.empty? || !arguments.last.splat?)
         return [Problem.new(location, "Not enough arguments to #{pin.path}")]
       end
       []
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     def required_param_count(pin)
-      count = 0
-      pin.parameters.each do |param|
-        break unless param.decl == :arg
-        count += 1
-      end
-      count
+      pin.parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     def optional_param_count(pin)
       count = 0
       pin.parameters.each do |param|