solargraph 0.39.7

data/lib/solargraph/source_map/clip.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    # A static analysis tool for obtaining definitions, completions,
+    # signatures, and type inferences from a cursor.
+    #
+    class Clip
+      # @param api_map [ApiMap]
+      # @param cursor [Source::Cursor]
+      def initialize api_map, cursor
+        @api_map = api_map
+        @cursor = cursor
+      end
+
+      # @return [Array<Pin::Base>]
+      def define
+        return [] if cursor.comment? || cursor.chain.literal?
+        result = cursor.chain.define(api_map, block, locals)
+        result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
+        result
+      end
+
+      # @return [Completion]
+      def complete
+        return package_completions([]) if !source_map.source.parsed? || cursor.string?
+        return package_completions(api_map.get_symbols) if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        return Completion.new([], cursor.range) if cursor.chain.literal? || cursor.comment?
+        result = []
+        result.concat complete_keyword_parameters
+        if cursor.chain.constant? || cursor.start_of_constant?
+          full = cursor.chain.links.first.word
+          type = if cursor.chain.undefined?
+            cursor.chain.base.infer(api_map, context_pin, locals)
+          else
+            if full.include?('::') && cursor.chain.links.length == 1
+              ComplexType.try_parse(full.split('::')[0..-2].join('::'))
+            elsif cursor.chain.links.length > 1
+              ComplexType.try_parse(full)
+            else
+              ComplexType::UNDEFINED
+            end
+          end
+          if type.undefined?
+            if full.include?('::')
+              result.concat api_map.get_constants(full, *gates)
+            else
+              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+            end
+          else
+            result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
+          end
+        else
+          type = cursor.chain.base.infer(api_map, block, locals)
+          result.concat api_map.get_complex_type_methods(type, block.binder.namespace, cursor.chain.links.length == 1)
+          if cursor.chain.links.length == 1
+            if cursor.word.start_with?('@@')
+              return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
+            elsif cursor.word.start_with?('@')
+              return package_completions(api_map.get_instance_variable_pins(block.binder.namespace, block.binder.scope))
+            elsif cursor.word.start_with?('$')
+              return package_completions(api_map.get_global_variable_pins)
+            end
+            result.concat locals
+            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 yielded_self_pins
+          end
+        end
+        package_completions(result)
+      end
+
+      # @return [Array<Pin::Base>]
+      def signify
+        return [] unless cursor.argument?
+        chain = Parser.chain(cursor.recipient_node, cursor.filename)
+        chain.define(api_map, context_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
+      end
+
+      # @return [ComplexType]
+      def infer
+        result = cursor.chain.infer(api_map, block, locals)
+        return result unless result.tag == 'self'
+        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).namespace)
+      end
+
+      # Get an array of all the locals that are visible from the cursors's
+      # position. Locals can be local variables, method parameters, or block
+      # parameters. The array starts with the nearest local pin.
+      #
+      # @return [Array<Solargraph::Pin::Base>]
+      def locals
+        loc_pos = context_pin.location.range.contain?(cursor.position) ? cursor.position : context_pin.location.range.ending
+        adj_pos = Position.new(loc_pos.line, (loc_pos.column.zero? ? 0 : loc_pos.column - 1))
+        @locals ||= source_map.locals.select { |pin|
+          pin.visible_from?(block, adj_pos)
+        }.reverse
+      end
+
+      def gates
+        block.gates
+      end
+
+      def in_block?
+        return @in_block unless @in_block.nil?
+        @in_block = begin
+          tree = cursor.source.tree_at(cursor.position.line, cursor.position.column)
+          Parser.is_ast_node?(tree[1]) && [:block, :ITER].include?(tree[1].type)
+        end
+      end
+
+      private
+
+      # @return [ApiMap]
+      attr_reader :api_map
+
+      # @return [Source::Cursor]
+      attr_reader :cursor
+
+      # @return [SourceMap]
+      def source_map
+        @source_map ||= api_map.source_map(cursor.filename)
+      end
+
+      # @return [Solargraph::Pin::Base]
+      def block
+        @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
+      end
+
+      # The context at the current position.
+      #
+      # @return [Pin::Base]
+      def context_pin
+        @context_pin ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
+      end
+
+      # @return [Array<Pin::Base>]
+      def yielded_self_pins
+        return [] unless block.is_a?(Pin::Block) && block.receiver
+        chain = Parser.chain(block.receiver, source_map.source.filename)
+        receiver_pin = chain.define(api_map, context_pin, locals).first
+        return [] if receiver_pin.nil?
+        result = []
+        ys = receiver_pin.docstring.tag(:yieldpublic)
+        unless ys.nil? || ys.types.empty?
+          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+          result.concat api_map.get_complex_type_methods(ysct, '', false)
+        end
+        result
+      end
+
+      # @return [Array<Pin::KeywordParam]
+      def complete_keyword_parameters
+        return [] unless cursor.argument? && cursor.chain.links.one? && cursor.word =~ /^[a-z0-9_]*:?$/
+        pins = signify
+        result = []
+        done = []
+        pins.each do |pin|
+          pin.parameters.each do |param|
+            next if done.include?(param.name)
+            done.push param.name
+            next unless param.keyword?
+            result.push Pin::KeywordParam.new(pin.location, "#{param.name}:")
+          end
+          if !pin.parameters.empty? && pin.parameters.last.kwrestarg?
+            pin.docstring.tags(:param).each do |tag|
+              next if done.include?(tag.name)
+              done.push tag.name
+              result.push Pin::KeywordParam.new(pin.location, "#{tag.name}:")
+            end
+          end
+        end
+        result
+      end
+
+      # @param result [Array<Pin::Base>]
+      # @return [Completion]
+      def package_completions result
+        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))
+        }
+        Completion.new(filtered, cursor.range)
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/completion.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    # The result of a completion request containing the pins that describe
+    # completion options and the range to be replaced.
+    #
+    class Completion
+      # @return [Array<Solargraph::Pin::Base>]
+      attr_reader :pins
+
+      # @return [Solargraph::Range]
+      attr_reader :range
+
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @param range [Solargraph::Range]
+      def initialize pins, range
+        @pins = pins
+        @range = range
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/mapper.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    # The Mapper generates pins and other data for SourceMaps.
+    #
+    # This class is used internally by the SourceMap class. Users should not
+    # normally need to call it directly.
+    #
+    class Mapper
+      # include Source::NodeMethods
+
+      private_class_method :new
+
+      MACRO_REGEXP = /(@\!method|@\!attribute|@\!domain|@\!macro|@\!parse|@\!override)/.freeze
+
+      # Generate the data.
+      #
+      # @param source [Source]
+      # @return [Array]
+      def map source
+        @source = source
+        @filename = source.filename
+        @code = source.code
+        @comments = source.comments
+        @pins, @locals = Parser.map(source)
+        process_comment_directives
+        [@pins, @locals]
+      # rescue Exception => e
+      #   Solargraph.logger.warn "Error mapping #{source.filename}: [#{e.class}] #{e.message}"
+      #   Solargraph.logger.warn e.backtrace.join("\n")
+      #   [[], []]
+      end
+
+      # @param filename [String]
+      # @param code [String]
+      # @return [Array]
+      def unmap filename, code
+        s = Position.new(0, 0)
+        e = Position.from_offset(code, code.length)
+        location = Location.new(filename, Range.new(s, e))
+        [[Pin::Namespace.new(location: location, name: '')], []]
+      end
+
+      class << self
+        # @param source [Source]
+        # @return [Array]
+        def map source
+          return new.unmap(source.filename, source.code) unless source.parsed?
+          new.map source
+        end
+      end
+
+      # @return [Array<Solargraph::Pin::Base>]
+      def pins
+        @pins ||= []
+      end
+
+      def closure_at(position)
+        @pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
+      end
+
+      def process_comment source_position, comment_position, comment
+        return unless comment =~ MACRO_REGEXP
+        cmnt = remove_inline_comment_hashes(comment)
+        parse = Solargraph::Source.parse_docstring(cmnt)
+        last_line = 0
+        # @param d [YARD::Tags::Directive]
+        parse.directives.each do |d|
+          line_num = find_directive_line_number(cmnt, d.tag.tag_name, last_line)
+          pos = Solargraph::Position.new(comment_position.line + line_num - 1, comment_position.column)
+          process_directive(source_position, pos, d)
+          last_line = line_num + 1
+          # @todo The below call assumes the topmost comment line. The above
+          #   process occasionally emits incorrect comment positions due to
+          #   blank lines in comment blocks, but at least it processes all the
+          #   directives.
+          # process_directive(source_position, comment_position, d)
+        end
+      end
+
+      # @param comment [String]
+      # @return [Integer]
+      def find_directive_line_number comment, tag, start
+        # Avoid overruning the index
+        return start unless start < comment.lines.length
+        num = comment.lines[start..-1].find_index do |line|
+          # Legacy method directives might be `@method` instead of `@!method`
+          # @todo Legacy syntax should probably emit a warning
+          line.include?("@!#{tag}") || (tag == 'method' && line.include?("@#{tag}"))
+        end
+        num.to_i + start
+      end
+
+      # @param source_position [Position]
+      # @param comment_position [Position]
+      # @param directive [YARD::Tags::Directive]
+      def process_directive source_position, comment_position, directive
+        docstring = Solargraph::Source.parse_docstring(directive.tag.text).to_docstring
+        location = Location.new(@filename, Range.new(comment_position, comment_position))
+        case directive.tag.tag_name
+        when 'method'
+          namespace = closure_at(source_position) || @pins.first
+          if namespace.location.range.start.line < comment_position.line
+            namespace = closure_at(comment_position)
+          end
+          region = Parser::Region.new(source: @source, closure: namespace)
+          begin
+            src_node = Parser.parse("def #{directive.tag.name};end", @filename, location.range.start.line)
+            gen_pin = Parser.process_node(src_node, region).first.last
+            return if gen_pin.nil?
+            # Move the location to the end of the line so it gets recognized
+            # as originating from a comment
+            shifted = Solargraph::Position.new(comment_position.line, @code.lines[comment_position.line].to_s.chomp.length)
+            # @todo: Smelly instance variable access
+            gen_pin.instance_variable_set(:@comments, docstring.all.to_s)
+            gen_pin.instance_variable_set(:@location, Solargraph::Location.new(@filename, Range.new(shifted, shifted)))
+            gen_pin.instance_variable_set(:@explicit, false)
+            @pins.push gen_pin
+          rescue Parser::SyntaxError => e
+            # @todo Handle error in directive
+          end
+        when 'attribute'
+          return if directive.tag.name.nil?
+          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(
+              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
+            )
+          end
+          if t.nil? || t.include?('w')
+            pins.push Solargraph::Pin::Attribute.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
+            )
+          end
+        when 'parse'
+          ns = closure_at(source_position)
+          region = Parser::Region.new(source: @source, closure: ns)
+          begin
+            node = Parser.parse(directive.tag.text, @filename, comment_position.line)
+            # @todo These pins may need to be marked not explicit
+            Parser.process_node(node, region, @pins)
+          rescue Parser::SyntaxError => e
+            # @todo Handle parser errors in !parse directives
+          end
+        when 'domain'
+          namespace = closure_at(source_position)
+          namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
+        when 'override'
+          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags)
+        end
+      end
+
+      def remove_inline_comment_hashes comment
+        ctxt = ''
+        num = nil
+        started = false
+        comment.lines.each { |l|
+          # Trim the comment and minimum leading whitespace
+          p = l.gsub(/^#/, '')
+          if num.nil? && !p.strip.empty?
+            num = p.index(/[^ ]/)
+            started = true
+          elsif started && !p.strip.empty?
+            cur = p.index(/[^ ]/)
+            num = cur if cur < num
+          end
+          ctxt += "#{p[num..-1]}" if started
+        }
+        ctxt
+      end
+
+      # @return [void]
+      def process_comment_directives
+        return unless @code =~ MACRO_REGEXP
+        code_lines = @code.lines
+        @source.associated_comments.each do |line, comments|
+          src_pos = line ? Position.new(line, code_lines[line].to_s.chomp.index(/[^\s]/) || 0) : Position.new(code_lines.length, 0)
+          com_pos = Position.new(line - 1, 0)
+          process_comment(src_pos, com_pos, comments)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/stdlib_fills.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # Overrides for the Ruby stdlib.
+  #
+  # The YardMap uses this module to add type information to stdlib methods.
+  #
+  module StdlibFills
+    Override = Pin::Reference::Override
+
+    LIBS = {
+      'benchmark' => [
+        Override.method_return('Benchmark.measure', 'Benchmark::Tms')
+      ],
+
+      'pathname' => [
+        Override.method_return('Pathname#join', 'Pathname'),
+        Override.method_return('Pathname#basename', 'Pathname'),
+        Override.method_return('Pathname#dirname', 'Pathname'),
+        Override.method_return('Pathname#cleanpath', 'Pathname'),
+        Override.method_return('Pathname#children', 'Array<Pathname>'),
+        Override.method_return('Pathname#entries', 'Array<Pathname>')
+      ]
+    }
+
+    # @param path [String]
+    # @return [Array<Pin::Reference::Override>]
+    def self.get path
+      LIBS[path] || []
+    end
+  end
+end

data/lib/solargraph/type_checker.rb

@@ -0,0 +1,498 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # A static analysis tool for validating data types.
+  #
+  class TypeChecker
+    autoload :Problem,  'solargraph/type_checker/problem'
+    autoload :ParamDef, 'solargraph/type_checker/param_def'
+    autoload :Rules,    'solargraph/type_checker/rules'
+    autoload :Checks,   'solargraph/type_checker/checks'
+
+    include Checks
+    include Parser::NodeMethods
+
+    # @return [String]
+    attr_reader :filename
+
+    # @return [Rules]
+    attr_reader :rules
+
+    # @return [ApiMap]
+    attr_reader :api_map
+
+    # @param filename [String]
+    # @param api_map [ApiMap]
+    # @param level [Symbol]
+    def initialize filename, api_map: nil, level: :normal
+      @filename = filename
+      # @todo Smarter directory resolution
+      @api_map = api_map || Solargraph::ApiMap.load(File.dirname(filename))
+      @rules = Rules.new(level)
+      @marked_ranges = []
+    end
+
+    # @return [SourceMap]
+    def source_map
+      @source_map ||= api_map.source_map(filename)
+    end
+
+    # @return [Array<Problem>]
+    def problems
+      @problems ||= begin
+        method_tag_problems
+          .concat variable_type_tag_problems
+          .concat const_problems
+          .concat call_problems
+      end
+    end
+
+    class << self
+      # @param filename [String]
+      # @return [self]
+      def load filename, level = :normal
+        source = Solargraph::Source.load(filename)
+        api_map = Solargraph::ApiMap.new
+        api_map.map(source)
+        new(filename, api_map: api_map, level: level)
+      end
+
+      # @param code [String]
+      # @param filename [String, nil]
+      # @return [self]
+      def load_string code, filename = nil, level = :normal
+        source = Solargraph::Source.load_string(code, filename)
+        api_map = Solargraph::ApiMap.new
+        api_map.map(source)
+        new(filename, api_map: api_map, level: level)
+      end
+    end
+
+    private
+
+    # @return [Array<Problem>]
+    def method_tag_problems
+      result = []
+      # @param pin [Pin::BaseMethod]
+      source_map.pins.select { |pin| pin.is_a?(Pin::BaseMethod) }.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]
+    # @return [Array<Problem>]
+    def method_return_type_problems_for pin
+      result = []
+      declared = pin.typify(api_map).self_to(pin.full_context.namespace)
+      if declared.undefined?
+        if pin.return_type.undefined? && rules.require_type_tags?
+          result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
+        elsif pin.return_type.defined?
+          result.push Problem.new(pin.location, "Unresolved return type #{pin.return_type} for #{pin.path}", pin: pin)
+        elsif rules.must_tag_or_infer? && pin.probe(api_map).undefined?
+          result.push Problem.new(pin.location, "Untyped method #{pin.path} could not be inferred")
+        end
+      elsif rules.validate_tags?
+        unless pin.node.nil? || declared.void? || macro_pin?(pin) || abstract?(pin)
+          inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+          if inferred.undefined?
+            unless rules.ignore_all_undefined? || external?(pin)
+              result.push Problem.new(pin.location, "#{pin.path} return type could not be inferred", pin: pin)
+            end
+          else
+            unless (rules.rank > 1 ? types_match?(api_map, declared, inferred) : any_types_match?(api_map, declared, inferred))
+              result.push Problem.new(pin.location, "Declared return type #{declared} does not match inferred type #{inferred} for #{pin.path}", pin: pin)
+            end
+          end
+        end
+      end
+      result
+    end
+
+    def macro_pin? pin
+      pin.location && source_map.source.comment_at?(pin.location.range.ending)
+    end
+
+    # @param pin [Pin::BaseMethod]
+    # @return [Array<Problem>]
+    def method_param_type_problems_for pin
+      stack = api_map.get_method_stack(pin.namespace, pin.name, scope: pin.scope)
+      params = first_param_hash(stack)
+      result = []
+      if rules.require_type_tags?
+        pin.parameters.each do |par|
+          break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
+          unless params[par.name]
+            result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+          end
+        end
+      end
+      params.each_pair do |name, tag|
+        type = tag.qualify(api_map, pin.full_context.namespace)
+        if type.undefined?
+          result.push Problem.new(pin.location, "Unresolved type #{tag} for #{name} param on #{pin.path}", pin: pin)
+        end
+      end
+      result
+    end
+
+    def ignored_pins
+      @ignored_pins ||= []
+    end
+
+    # @return [Array<Problem>]
+    def variable_type_tag_problems
+      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
+                  result.push Problem.new(pin.location, "Variable type could not be inferred for #{pin.name}", pin: pin)
+                end
+              else
+                unless (rules.rank > 1 ? types_match?(api_map, declared, inferred) : any_types_match?(api_map, declared, inferred))
+                  result.push Problem.new(pin.location, "Declared type #{declared} does not match inferred type #{inferred} for variable #{pin.name}", pin: pin)
+                end
+              end
+            elsif declared_externally?(pin)
+              ignored_pins.push pin
+            end
+          elsif !pin.is_a?(Pin::Parameter)
+            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
+          end
+        end
+      end
+      result
+    end
+
+    # @return [Array<Pin::BaseVariable>]
+    def all_variables
+      source_map.pins.select { |pin| pin.is_a?(Pin::BaseVariable) } +
+        source_map.locals.select { |pin| pin.is_a?(Pin::LocalVariable) }
+    end
+
+    def const_problems
+      return [] unless rules.validate_consts?
+      result = []
+      Solargraph::Parser::NodeMethods.const_nodes_from(source_map.source.node).each do |const|
+        rng = Solargraph::Range.from_node(const)
+        chain = Solargraph::Parser.chain(const, filename)
+        block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+        location = Location.new(filename, rng)
+        locals = source_map.locals_at(location)
+        pins = chain.define(api_map, block_pin, locals)
+        if pins.empty?
+          result.push Problem.new(location, "Unresolved constant #{Solargraph::Parser::NodeMethods.unpack_name(const)}")
+          @marked_ranges.push location.range
+        end
+      end
+      result
+    end
+
+    def call_problems
+      result = []
+      Solargraph::Parser::NodeMethods.call_nodes_from(source_map.source.node).each do |call|
+        rng = Solargraph::Range.from_node(call)
+        next if @marked_ranges.any? { |d| d.contain?(rng.start) }
+        chain = Solargraph::Parser.chain(call, filename)
+        block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+        location = Location.new(filename, rng)
+        locals = source_map.locals_at(location)
+        type = chain.infer(api_map, block_pin, locals)
+        if type.undefined? && !rules.ignore_all_undefined?
+          base = chain
+          missing = chain
+          found = nil
+          closest = ComplexType::UNDEFINED
+          until base.links.first.undefined?
+            found = base.define(api_map, block_pin, locals).first
+            break if found
+            missing = base
+            base = base.base
+          end
+          closest = found.typify(api_map) if found
+          if !found || closest.defined? || internal?(found)
+            unless ignored_pins.include?(found)
+              result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
+              @marked_ranges.push rng
+            end
+          end
+        end
+        result.concat argument_problems_for(chain, api_map, block_pin, locals, location)
+      end
+      result
+    end
+
+    def argument_problems_for chain, api_map, block_pin, locals, location
+      result = []
+      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]
+          pin = pins.first
+          ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
+            arity_problems_for(pin, fake_args_for(block_pin), location)
+          else
+            arity_problems_for(pin, base.links.last.arguments, location)
+          end
+          unless ap.empty?
+            result.concat ap
+            break
+          end
+          break unless rules.validate_calls?
+          params = first_param_hash(pins)
+          pin.parameters.each_with_index do |par, idx|
+            argchain = base.links.last.arguments[idx]
+            if argchain.nil? && par.decl == :arg
+              result.push Problem.new(location, "Not enough arguments to #{pin.path}")
+              break
+            end
+            if argchain
+              if par.decl != :arg
+                result.concat kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
+                break
+              else
+                ptype = params[par.name]
+                if ptype.nil?
+                  # @todo Some level (strong, I guess) should require the param here
+                else
+                  argtype = argchain.infer(api_map, block_pin, locals)
+                  if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
+                    result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                  end
+                end
+              end
+            elsif par.rest?
+              next
+            elsif par.decl == :kwarg
+              result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+              break
+            end
+          end
+        end
+        base = base.base
+      end
+      result
+    end
+
+    def kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, first
+      result = []
+      kwargs = convert_hash(argchain.node)
+      pin.parameters[first..-1].each_with_index do |par, cur|
+        idx = first + cur
+        argchain = kwargs[par.name.to_sym]
+        if par.decl == :kwrestarg || (par.decl == :optarg && idx == pin.parameters.length - 1 && par.asgn_code == '{}')
+          result.concat kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
+        else
+          if argchain
+            ptype = params[par.name]
+            if ptype.nil?
+              # @todo Some level (strong, I guess) should require the param here
+            else
+              argtype = argchain.infer(api_map, block_pin, locals)
+              if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
+                result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+              end
+            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
+        end
+      end
+      result
+    end
+
+    def kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
+      result = []
+      kwargs.each_pair do |pname, argchain|
+        ptype = params[pname.to_s]
+        if ptype.nil?
+          # Probably nothing to do here. All of these args should be optional.
+        else
+          argtype = argchain.infer(api_map, block_pin, locals)
+          if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
+            result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{pname} expected #{ptype}, received #{argtype}")
+          end
+        end
+      end
+      result
+    end
+
+    def param_hash(pin)
+      tags = pin.docstring.tags(:param)
+      return {} if tags.empty?
+      result = {}
+      tags.each do |tag|
+        next if tag.types.nil? || tag.types.empty?
+        result[tag.name.to_s] = Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
+      end
+      result
+    end
+
+    # @param [Array<Pin::Method>]
+    def first_param_hash(pins)
+      pins.each do |pin|
+        result = param_hash(pin)
+        return result unless result.empty?
+      end
+      {}
+    end
+
+    # @param pin [Pin::Base]
+    def internal? pin
+      pin.location && api_map.bundled?(pin.location.filename)
+    end
+
+    # @param pin [Pin::Base]
+    def external? pin
+      !internal? pin
+    end
+
+    def declared_externally? pin
+      return true if pin.assignment.nil?
+      chain = Solargraph::Parser.chain(pin.assignment, filename)
+      rng = Solargraph::Range.from_node(pin.assignment)
+      block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
+      location = Location.new(filename, Range.from_node(pin.assignment))
+      locals = source_map.locals_at(location)
+      type = chain.infer(api_map, block_pin, locals)
+      if type.undefined? && !rules.ignore_all_undefined?
+        base = chain
+        missing = chain
+        found = nil
+        closest = ComplexType::UNDEFINED
+        until base.links.first.undefined?
+          found = base.define(api_map, block_pin, locals).first
+          break if found
+          missing = base
+          base = base.base
+        end
+        closest = found.typify(api_map) if found
+        if !found || closest.defined? || internal?(found)
+          return false
+        end
+      end
+      true
+    end
+
+    # @param pin [Pin::BaseMethod]
+    def arity_problems_for(pin, arguments, location)
+      return [] unless pin.explicit?
+      return [] if pin.parameters.empty? && arguments.empty?
+      if pin.parameters.empty?
+        # Functions tagged param_tuple accepts two arguments (e.g., Hash#[]=)
+        return [] if pin.docstring.tag(:param_tuple) && arguments.length == 2
+        return [] if arguments.length == 1 && arguments.last.links.last.is_a?(Source::Chain::BlockVariable)
+        return [Problem.new(location, "Too many arguments to #{pin.path}")]
+      end
+      unchecked = arguments.clone
+      add_params = 0
+      if unchecked.empty? && pin.parameters.any? { |param| param.decl == :kwarg }
+        return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
+      end
+      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}")]
+              end
+            end
+          end
+        # end
+      end
+      req = required_param_count(pin)
+      if req + add_params < unchecked.length
+        return [] if pin.parameters.any?(&:rest?)
+        opt = optional_param_count(pin)
+        return [] if unchecked.length <= req + opt
+        if unchecked.length == req + opt + 1 && unchecked.last.links.last.is_a?(Source::Chain::BlockVariable)
+          return []
+        end
+        return [Problem.new(location, "Too many arguments to #{pin.path}")]
+      elsif unchecked.length < req && (arguments.empty? || !arguments.last.splat?)
+        return [Problem.new(location, "Not enough arguments to #{pin.path}")]
+      end
+      []
+    end
+
+    # @param pin [Pin::BaseMethod]
+    def required_param_count(pin)
+      count = 0
+      pin.parameters.each do |param|
+        break unless param.decl == :arg
+        count += 1
+      end
+      count
+    end
+
+    # @param pin [Pin::BaseMethod]
+    def optional_param_count(pin)
+      count = 0
+      pin.parameters.each do |param|
+        next unless param.decl == :optarg
+        count += 1
+      end
+      count
+    end
+
+    def abstract? pin
+      pin.docstring.has_tag?(:abstract) ||
+        (pin.closure && pin.closure.docstring.has_tag?(:abstract))
+    end
+
+    def fake_args_for(pin)
+      args = []
+      with_opts = false
+      with_block = false
+      pin.parameters.each do |pin|
+        if [:kwarg, :kwoptarg, :kwrestarg].include?(pin.decl)
+          with_opts = true
+        elsif pin.decl == :block
+          with_block = true
+        elsif pin.decl == :restarg
+          args.push Solargraph::Source::Chain.new([Solargraph::Source::Chain::Variable.new(pin.name)], nil, true)
+        else
+          args.push Solargraph::Source::Chain.new([Solargraph::Source::Chain::Variable.new(pin.name)])
+        end
+      end
+      args.push Solargraph::Parser.chain_string('{}') if with_opts
+      args.push Solargraph::Parser.chain_string('&') if with_block
+      args
+    end
+  end
+end