solargraph 0.25.1 → 0.26.0

data/lib/solargraph/source/mapper.rb

@@ -20,11 +20,15 @@ module Solargraph
         @node = node
         @node_stack = []
         @directives = {}
+        @comment_ranges = comments.map do |c|
+          Source::Range.from_to(c.loc.expression.line, c.loc.expression.column, c.loc.expression.last_line, c.loc.expression.last_column)
+        end
         @node_comments = associate_comments(node, comments)
         @pins = []
         @requires = []
         @symbols = []
         @locals = []
+        @strings = []
 
         @used_comment_locs = []
 
@@ -37,7 +41,8 @@ module Solargraph
         @node_comments.reject{|k, v| @used_comment_locs.include?(k)}.each do |k, v|
           @pins.first.comments.concat v
         end
-        [@pins, @locals, @requires, @symbols]
+
+        [@pins, @locals, @requires, @symbols, @strings, @comment_ranges]
       end
 
       class << self
@@ -70,7 +75,13 @@ module Solargraph
         @pins ||= []
       end
 
+      # @param node [Parser::AST::Node]
       def process node, tree = [], visibility = :public, scope = :instance, fqn = '', stack = []
+        return unless node.is_a?(AST::Node)
+        if node.type == :str
+          @strings.push Source::Range.from_to(node.loc.expression.line, node.loc.expression.column, node.loc.expression.last_line, node.loc.expression.last_column)
+          return
+        end
         stack.push node
         if node.kind_of?(AST::Node)
           @node_stack.unshift node
@@ -98,17 +109,17 @@ module Solargraph
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:ivasgn, c.children + ora.children[1..-1], nil)
-                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context)
+                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), context)
                     if visibility == :module_function and context.kind == Pin::METHOD
                       other = pins.select{|pin| pin.path == "#{context.namespace}.#{context.name}"}.first
-                      pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), other) unless other.nil?
+                      pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), other) unless other.nil?
                     end
                   end
                 else
-                  pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context)
+                  pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), context)
                   if visibility == :module_function and context.kind == Pin::METHOD
                     other = pins.select{|pin| pin.path == "#{context.namespace}.#{context.name}"}.first
-                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), other)
+                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), other)
                   end
                 end
               elsif c.type == :cvasgn
@@ -118,10 +129,10 @@ module Solargraph
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:cvasgn, c.children + ora.children[1..-1], nil)
-                    pins.push Solargraph::Pin::ClassVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context)
+                    pins.push Solargraph::Pin::ClassVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), context)
                   end
                 else
-                  pins.push Solargraph::Pin::ClassVariable.new(get_node_location(c), fqn || '', c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context)
+                  pins.push Solargraph::Pin::ClassVariable.new(get_node_location(c), fqn || '', c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), context)
                 end
               elsif c.type == :lvasgn
                 here = get_node_start_position(c)
@@ -132,25 +143,25 @@ module Solargraph
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:lvasgn, c.children + ora.children[1..-1], nil)
-                    @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(ora), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context, block, presence)
+                    @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(ora), c.children[1], infer_literal_node_type(c.children[1]), context, block, presence)
                   end
                 else
-                  @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context, block, presence)
+                  @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), context, block, presence)
                 end
               elsif c.type == :gvasgn
-                pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), @pins.first)
+                pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), @pins.first)
               elsif c.type == :sym
                 @symbols.push Solargraph::Pin::Symbol.new(get_node_location(c), ":#{c.children[0]}")
               elsif c.type == :casgn
                 here = get_node_start_position(c)
                 block = get_block_pin(here)
-                pins.push Solargraph::Pin::Constant.new(get_node_location(c), fqn, c.children[1].to_s, comments_for(c), resolve_node_signature(c.children[2]), infer_literal_node_type(c.children[2]), block, :public)
+                pins.push Solargraph::Pin::Constant.new(get_node_location(c), fqn, c.children[1].to_s, comments_for(c), c.children[2], infer_literal_node_type(c.children[2]), block, :public)
               elsif c.type == :def
                 methpin = Solargraph::Pin::Method.new(get_node_location(c), fqn || '', c.children[(c.type == :def ? 0 : 1)].to_s, comments_for(c), scope, visibility, get_method_args(c))
                 if methpin.name == 'initialize' and methpin.scope == :instance
                   pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, 'new', methpin.comments, :class, :public, methpin.parameters)
                   # @todo Smelly instance variable access.
-                  pins.last.instance_variable_set(:@return_complex_types, ComplexType.parse(methpin.namespace))
+                  pins.last.instance_variable_set(:@return_complex_type, ComplexType.parse(methpin.namespace))
                   pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, methpin.scope, :private, methpin.parameters)
                 elsif visibility == :module_function
                   pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, :class, :public, methpin.parameters)
@@ -290,7 +301,7 @@ module Solargraph
                   end
                 end
               elsif c.type == :block
-                @pins.push Solargraph::Pin::Block.new(get_node_location(c), fqn || '', '', comments_for(c), resolve_node_signature(c.children[0]))
+                @pins.push Solargraph::Pin::Block.new(get_node_location(c), fqn || '', '', comments_for(c), c.children[0], scope)
               end
               process c, tree, visibility, scope, fqn, stack
             end
@@ -333,8 +344,8 @@ module Solargraph
           st = Position.new(0, 0)
           en = Position.from_offset(@code, @code.length)
         else
-          st = Position.new(node.loc.line - 1, node.loc.column)
-          en = Position.new(node.loc.last_line - 1, node.loc.last_column)
+          st = Position.new(node.loc.line, node.loc.column)
+          en = Position.new(node.loc.last_line, node.loc.last_column)
         end
         range = Range.new(st, en)
         Location.new(filename, range)
@@ -371,7 +382,7 @@ module Solargraph
       # @param node [Parser::AST::Node]
       # @return [Solargraph::Pin::Namespace]
       def namespace_for(node)
-        position = Source::Position.new(node.loc.line - 1, node.loc.column)
+        position = Source::Position.new(node.loc.line, node.loc.column)
         @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.location.range.contain?(position)}.last
       end
 

data/lib/solargraph/source/node_chainer.rb

@@ -0,0 +1,94 @@
+module Solargraph
+  class Source
+    class NodeChainer
+      include NodeMethods
+
+      def initialize filename, node
+        @filename = filename
+        @node = node
+        # @source = source
+        # @line = line
+        # @column = column
+      end
+
+      # @return [Source::Chain]
+      def chain
+        links = generate_links(@node)
+        Chain.new(@filename, links)
+      end
+
+      class << self
+        # @param source [Source]
+        # @param line [Integer]
+        # @param column [Integer]
+        # @return [Source::Chain]
+        def chain filename, node
+          NodeChainer.new(filename, node).chain
+        end
+
+        # @param code [String]
+        # @return [Chain]
+        def load_string(filename, code)
+          node = Source.parse_node(code.sub(/\.$/, ''), filename)
+          chain = Chain.new(filename, node)
+          chain.links.push(Chain::Link.new) if code.end_with?('.')
+          chain
+        end
+      end
+
+      private
+
+      # @param n [Parser::AST::Node]
+      # @return [Array<Chain::Link>]
+      def generate_links n
+        return [] if n.nil?
+        return generate_links(n.children[0]) if n.type == :begin
+        # @todo This might not be right. It's weird either way.
+        # return generate_links(n.children[2] || n.children[0]) if n.type == :block
+        result = []
+        if n.type == :block
+          # result.concat generate_links(n.children[2])
+          result.concat generate_links(n.children[0])
+        elsif n.type == :send
+          if n.children[0].is_a?(Parser::AST::Node)
+            result.concat generate_links(n.children[0])
+            args = []
+            n.children[2..-1].each do |c|
+              # @todo Handle link parameters
+              # args.push Chain.new(source, c.loc.last_line - 1, c.loc.column)
+            end
+            result.push Chain::Call.new(n.children[1].to_s, args)
+          elsif n.children[0].nil?
+            args = []
+            n.children[2..-1].each do |c|
+              # @todo Handle link parameters
+              # args.push Chain.new(source, c.loc.last_line - 1, c.loc.column)
+            end
+            result.push Chain::Call.new(n.children[1].to_s, args)
+          else
+            raise "No idea what to do with #{n}"
+          end
+        elsif n.type == :self
+          result.push Chain::Call.new('self')
+        elsif n.type == :const
+          result.push Chain::Constant.new(unpack_name(n))
+        elsif [:lvar, :lvasgn].include?(n.type)
+          result.push Chain::Call.new(n.children[0].to_s)
+        elsif [:ivar, :ivasgn].include?(n.type)
+          result.push Chain::InstanceVariable.new(n.children[0].to_s)
+        elsif [:cvar, :cvasgn].include?(n.type)
+          result.push Chain::ClassVariable.new(n.children[0].to_s)
+        elsif [:gvar, :gvasgn].include?(n.type)
+          result.push Chain::GlobalVariable.new(n.children[0].to_s)
+        elsif [:class, :module, :def, :defs].include?(n.type)
+          location = Solargraph::Source::Location.new(@filename, Source::Range.from_to(n.loc.expression.line - 1, n.loc.expression.column, n.loc.expression.last_line - 1, n.loc.expression.last_column))
+          result.push Chain::Definition.new(location)
+        else
+          lit = infer_literal_node_type(n)
+          result.push (lit ? Chain::Literal.new(lit) : Chain::Link.new)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/solargraph/source/node_methods.rb

@@ -79,11 +79,11 @@ module Solargraph
       end
 
       def get_node_start_position(node)
-        Position.new(node.loc.line - 1, node.loc.column)
+        Position.new(node.loc.line, node.loc.column)
       end
 
       def get_node_end_position(node)
-        Position.new(node.loc.last_line - 1, node.loc.last_column)
+        Position.new(node.loc.last_line, node.loc.last_column)
       end
 
       def drill_signature node, signature

data/lib/solargraph/source/position.rb

@@ -13,6 +13,10 @@ module Solargraph
         @character = character
       end
 
+      def column
+        character
+      end
+
       # Get a hash of the position. This representation is suitable for use in
       # the language server protocol.
       #

data/lib/solargraph/source/range.rb

@@ -27,15 +27,23 @@ module Solargraph
 
       # True if the specified position is inside the range.
       #
+      # @param position [Solargraph::Source::Position]
       # @return [Boolean]
       def contain? position
-        return false if position.line < start.line
+        return false if position.line < start.line or position.line > ending.line
         return false if position.line == start.line and position.character < start.character
-        return false if position.line > ending.line
         return false if position.line == ending.line and position.character > ending.character
         true
       end
 
+      # True if the range contains the specified position and the position does not precede it.
+      #
+      # @param position [Source::Position]
+      # @return [Boolean]
+      def include? position
+        contain?(position) and !(position.line == start.line and position.character == start.character)
+      end
+
       # Create a range from a pair of lines and characters.
       #
       # @param l1 [Integer] Starting line

data/lib/solargraph/version.rb

@@ -1,3 +1,3 @@
 module Solargraph
-  VERSION = '0.25.1'
+  VERSION = '0.26.0'
 end

data/lib/solargraph/yard_map.rb

@@ -26,6 +26,8 @@ module Solargraph
     # @return [Array<String>]
     attr_reader :required
 
+    # @param required [Array<String>]
+    # @param workspace [Solargraph::Workspace, nil]
     def initialize(required: [], workspace: nil)
       @workspace = workspace
       # HACK: YardMap needs its own copy of this array
@@ -69,7 +71,7 @@ module Solargraph
       end
     end
 
-    # @param paths [Array<String>]
+    # @param new_requires [Array<String>]
     # @return [Boolean]
     def change new_requires
       if new_requires.uniq.sort == required.uniq.sort
@@ -82,6 +84,7 @@ module Solargraph
       end
     end
 
+    # @return [Array<Solargraph::Pin::Base>]
     def core_pins
       @@core_pins ||= begin
         result = []
@@ -100,6 +103,8 @@ module Solargraph
       @cache ||= YardMap::Cache.new
     end
 
+    # @param ns [YARD::CodeObjects::Namespace]
+    # @return [Array<Solargraph::Pin::Base>]
     def recurse_namespace_object ns
       result = []
       ns.children.each do |c|
@@ -109,6 +114,8 @@ module Solargraph
       result
     end
 
+    # @param code_object [YARD::CodeObjects::Base]
+    # @return [Solargraph::Pin::Base]
     def generate_pin code_object
       location = object_location(code_object)
       if code_object.is_a?(YARD::CodeObjects::NamespaceObject)
@@ -122,6 +129,7 @@ module Solargraph
       end
     end
 
+    # @return [void]
     def process_requires
       pins.clear
       unresolved_requires.clear
@@ -177,6 +185,8 @@ module Solargraph
       pins.concat core_pins
     end
 
+    # @param required_namespaces [Array<YARD::CodeObjects::Namespace>]
+    # @return [Array<Solargraph::Pin::Base>]
     def process_stdlib required_namespaces
       pins = []
       unless required_namespaces.empty?
@@ -199,6 +209,7 @@ module Solargraph
     end
 
     # @param spec [Gem::Specification]
+    # @return [void]
     def add_gem_dependencies spec
       (spec.dependencies - spec.development_dependencies).each do |dep|
         depspec = Gem::Specification.find_by_name(dep.name)
@@ -218,7 +229,7 @@ module Solargraph
       return nil if obj.file.nil? or obj.line.nil?
       @gem_paths.values.each do |path|
         file = File.join(path, obj.file)
-        return Solargraph::Source::Location.new(file, Solargraph::Source::Range.from_to(obj.line - 1, 0, obj.line - 1, 0)) if File.exist?(file)
+        return Solargraph::Source::Location.new(file, Solargraph::Source::Range.from_to(obj.line, 0, obj.line, 0)) if File.exist?(file)
       end
       nil
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.25.1
+  version: 0.26.0
 platform: ruby
 authors:
 - Fred Snyder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-20 00:00:00.000000000 Z
+date: 2018-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -236,11 +236,10 @@ files:
 - lib/solargraph.rb
 - lib/solargraph/api_map.rb
 - lib/solargraph/api_map/cache.rb
-- lib/solargraph/api_map/completion.rb
-- lib/solargraph/api_map/probe.rb
 - lib/solargraph/api_map/source_to_yard.rb
 - lib/solargraph/api_map/store.rb
-- lib/solargraph/api_map/type_methods.rb
+- lib/solargraph/basic_type.rb
+- lib/solargraph/basic_type_methods.rb
 - lib/solargraph/complex_type.rb
 - lib/solargraph/core_fills.rb
 - lib/solargraph/diagnostics.rb
@@ -324,7 +323,7 @@ files:
 - lib/solargraph/pin/method_parameter.rb
 - lib/solargraph/pin/namespace.rb
 - lib/solargraph/pin/plugin/method.rb
-- lib/solargraph/pin/proxy_method.rb
+- lib/solargraph/pin/proxy_type.rb
 - lib/solargraph/pin/reference.rb
 - lib/solargraph/pin/symbol.rb
 - lib/solargraph/pin/yard_pin.rb
@@ -340,11 +339,26 @@ files:
 - lib/solargraph/server_methods.rb
 - lib/solargraph/shell.rb
 - lib/solargraph/source.rb
+- lib/solargraph/source/call_chainer.rb
+- lib/solargraph/source/chain.rb
+- lib/solargraph/source/chain/call.rb
+- lib/solargraph/source/chain/class_variable.rb
+- lib/solargraph/source/chain/constant.rb
+- lib/solargraph/source/chain/definition.rb
+- lib/solargraph/source/chain/global_variable.rb
+- lib/solargraph/source/chain/head.rb
+- lib/solargraph/source/chain/instance_variable.rb
+- lib/solargraph/source/chain/link.rb
+- lib/solargraph/source/chain/literal.rb
+- lib/solargraph/source/chain/variable.rb
 - lib/solargraph/source/change.rb
+- lib/solargraph/source/completion.rb
+- lib/solargraph/source/encoding_fixes.rb
 - lib/solargraph/source/flawed_builder.rb
 - lib/solargraph/source/fragment.rb
 - lib/solargraph/source/location.rb
 - lib/solargraph/source/mapper.rb
+- lib/solargraph/source/node_chainer.rb
 - lib/solargraph/source/node_methods.rb
 - lib/solargraph/source/position.rb
 - lib/solargraph/source/range.rb

data/lib/solargraph/api_map/probe.rb

@@ -1,251 +0,0 @@
-module Solargraph
-  class ApiMap
-    # A deep analysis provider for ApiMaps.
-    #
-    class Probe
-      include TypeMethods
-
-      # @return [Solargraph::ApiMap]
-      attr_reader :api_map
-
-      # @param api_map [ApiMap]
-      def initialize api_map
-        @api_map = api_map
-      end
-
-      # Get all matching pins for the signature.
-      #
-      # @param signature [String]
-      # @param context_pin [Pin::Base]
-      # @param locals [Array<Pin::Base>]
-      # @return [Array<Pin::Base>]
-      def infer_signature_pins signature, context_pin, locals
-        return [] if signature.nil? or signature.empty?
-        base, rest = signature.split('.', 2)
-        return infer_word_pins(base, context_pin, locals) if rest.nil?
-        pins = infer_word_pins(base, context_pin, locals).map do |pin|
-          next pin unless pin.return_type.nil?
-          type = resolve_pin_type(pin, locals - [pin])
-          Pin::ProxyMethod.new(type)
-        end
-        return [] if pins.empty?
-        rest = rest.split('.')
-        last = rest.pop
-        rest.each do |meth|
-          found = nil
-          pins.each do |pin|
-            found = infer_method_name_pins(meth, pin)
-            next if found.empty?
-            pins = found
-            break
-          end
-          return [] if found.nil?
-        end
-        pins.each do |pin|
-          found = infer_method_name_pins(last, pin)
-          return found unless found.empty?
-        end
-        []
-      end
-
-      # Get the return type for the signature.
-      #
-      # @param signature [String]
-      # @param context_pin [Pin::Base]
-      # @param locals [Array<Pin::Base>]
-      # @return [String]
-      def infer_signature_type signature, context_pin, locals
-        pins = infer_signature_pins(signature, context_pin, locals)
-        pins.each do |pin|
-          return qualify(pin.return_type, pin.named_context) unless pin.return_type.nil?
-          type = resolve_pin_type(pin, locals - [pin])
-          return qualify(type, pin.named_context) unless type.nil?
-        end
-        nil
-      end
-
-      private
-
-      # Word search is ALWAYS internal
-      def infer_word_pins word, context_pin, locals
-        return [] if word.empty?
-        return infer_self(context_pin) if word == 'self'
-        lvars = locals.select{|pin| pin.name == word}
-        return resolve_word_types(lvars, locals) unless lvars.empty?
-        return api_map.get_global_variable_pins.select{|pin| pin.name == word} if word.start_with?('$')
-        namespace, scope = extract_namespace_and_scope_from_pin(context_pin)
-        return api_map.get_class_variable_pins(namespace).select{|pin| pin.name == word} if word.start_with?('@@')
-        return api_map.get_instance_variable_pins(namespace, scope).select{|pin| pin.name == word} if word.start_with?('@')
-        return api_map.pins.select{|pin| word_matches_context?(word, namespace, scope, pin)} if variable_name?(word)
-        result = []
-        cparts = namespace.split('::')
-        until cparts.empty?
-          break unless result.empty?
-          cur = cparts.join('::')
-          result.concat api_map.get_path_suggestions("#{cur}::#{word}")
-          cparts.pop
-        end
-        result.concat api_map.get_path_suggestions(word) if result.empty?
-        # result.concat api_map.get_methods(namespace, scope: scope, visibility: [:public, :private, :protected]).select{|pin| pin.name == word} unless word.include?('::')
-        result.concat api_map.get_method_stack(namespace, word, scope: scope) unless word.include?('::')
-        result.concat api_map.get_constants('', namespace).select{|pin| pin.name == word} if result.empty?
-        resolve_word_types(result, locals)
-      end
-
-      def resolve_word_types(pins, locals)
-        pins.each do |p|
-          next unless p.return_type.nil?
-          type = resolve_pin_type(p, locals)
-          # @todo Smelly instance variable access
-          p.instance_variable_set(:@return_complex_types, ComplexType.parse(type)) unless type.nil?
-        end
-        pins
-      end
-
-      def infer_self context_pin
-        if context_pin.kind == Pin::METHOD
-          if context_pin.scope == :instance
-            return [Pin::ProxyMethod.new(context_pin.namespace)]
-          else
-            return api_map.get_path_suggestions(context_pin.namespace)
-          end
-        else
-          return api_map.get_path_suggestions(context_pin.path)
-        end
-      end
-
-      # Method name search is external by default
-      # @param method_name [String]
-      # @param context_pin [Solargraph::Pin::Base]
-      def infer_method_name_pins method_name, context_pin, internal = false
-        relname, scope = extract_namespace_and_scope(context_pin.return_type)
-        namespace = api_map.qualify(relname, context_pin.namespace)
-        visibility = [:public]
-        visibility.push :protected, :private if internal
-        # result = api_map.get_methods(namespace, scope: scope, visibility: visibility).select{|pin| pin.name == method_name}
-        result = api_map.get_method_stack(namespace, method_name, scope: scope).select{|pin| visibility.include?(pin.visibility)}
-        # @todo This needs more rules. Probably need to update YardObject for it.
-        return result if result.empty?
-        return result unless method_name == 'new' and result.first.path == 'Class#new'
-        result.unshift virtual_new_pin(result.first, context_pin)
-        result
-      end
-
-      # Word and context matching rules for ApiMap source pins.
-      #
-      # @return [Boolean]
-      def word_matches_context? word, namespace, scope, pin
-        return false unless word == pin.name
-        return true if pin.kind == Pin::NAMESPACE and pin.path == namespace and scope == :class
-        return true if pin.kind == Pin::METHOD and pin.namespace == namespace and pin.scope == scope
-        # @todo Handle instance variables, class variables, etc. in various ways
-        pin.namespace == namespace and pin.scope == scope
-      end
-
-      # Fully qualify the namespace in a type.
-      #
-      # @return [String]
-      def qualify type, context
-        rns, rsc = extract_namespace_and_scope(type)
-        res = api_map.qualify(rns, context)
-        return res if rsc == :instance
-        type.sub(/<#{rns}>/, "<#{res}>")
-      end
-
-      # Extract a namespace and a scope from a pin. For now, the pin must
-      # be either a namespace, a method, or a block.
-      #
-      # @return [Array] The namespace (String) and scope (Symbol).
-      def extract_namespace_and_scope_from_pin pin
-        return [pin.namespace, pin.scope] if pin.kind == Pin::METHOD
-        return [pin.path, :class] if pin.kind == Pin::NAMESPACE
-        # @todo Is :class appropriate for blocks?
-        return [pin.namespace, :class] if pin.kind == Pin::BLOCK
-        raise "Unable to extract namespace and scope from #{pin.path}"
-      end
-
-      # Determine whether or not the word represents a variable. This method
-      # is used to keep the probe from performing unnecessary constant and
-      # method searches.
-      #
-      # @return [Boolean]
-      def variable_name? word
-        word.start_with?('@') or word.start_with?('$')
-      end
-
-      # Create a `new` pin to facilitate type inference. This is necessary for
-      # classes from YARD and classes in the namespace that do not have an
-      # `initialize` method.
-      #
-      # @return [Pin::Method]
-      def virtual_new_pin new_pin, context_pin
-        pin = Pin::Method.new(new_pin.location, context_pin.path, new_pin.name, '', :class, new_pin.visibility, new_pin.parameters)
-        # @todo Smelly instance variable access.
-        pin.instance_variable_set(:@return_complex_types, ComplexType.parse(context_pin.path))
-        pin
-      end
-
-      # @param pin [Solargraph::Pin::Base]
-      # @param locals [Array<Solargraph::Pin::Base>]
-      # @return [String]
-      def resolve_pin_type pin, locals
-        return pin.return_type unless pin.return_type.nil?
-        return pin.namespace if pin.kind == Pin::METHOD and pin.name == 'new' and pin.scope == :class
-        return resolve_block_parameter(pin, locals) if pin.kind == Pin::BLOCK_PARAMETER
-        return resolve_method_parameter(pin) if pin.is_a?(Pin::MethodParameter)
-        return resolve_variable(pin, locals) if pin.variable?
-        nil
-      end
-
-      def resolve_block_parameter pin, locals
-        return pin.return_type unless pin.return_type.nil?
-        signature = pin.block.receiver
-        # @todo Not sure if assuming the first pin is good here
-        meth = infer_signature_pins(signature, pin.block, locals).first
-        return nil if meth.nil?
-        if (Solargraph::CoreFills::METHODS_WITH_YIELDPARAM_SUBTYPES.include?(meth.path))
-          base = signature.split('.')[0..-2].join('.')
-          return nil if base.nil? or base.empty?
-          # @todo Not sure if assuming the first pin is good here
-          bmeth = infer_signature_pins(base, pin.block, locals).first
-          return nil if bmeth.nil?
-          btype = bmeth.return_type
-          btype = infer_signature_type(bmeth.signature, pin.block, locals) if btype.nil? and bmeth.variable?
-          subtypes = get_subtypes(btype)
-          return nil if subtypes.nil?
-          return subtypes[0]
-        else
-          yps = meth.docstring.tags(:yieldparam)
-          unless yps[pin.index].nil? or yps[pin.index].types.nil? or yps[pin.index].types.empty?
-            return yps[pin.index].types[0]
-          end
-        end
-        nil
-      end
-
-      def resolve_method_parameter pin
-        matches = api_map.get_method_stack(pin.namespace, pin.context.name, scope: pin.scope)
-        matches.each do |m|
-          next unless pin.context.parameters == m.parameters
-          tag = m.docstring.tags(:param).select{|t| t.name == pin.name}.first
-          next if tag.nil? or tag.types.nil?
-          return tag.types[0]
-        end
-        nil
-      end
-
-      def resolve_variable(pin, locals)
-        return nil if pin.nil_assignment?
-        # @todo Do we need the locals here?
-        return infer_signature_type(pin.signature, pin.context, locals)
-      end
-
-      def get_subtypes type
-        return nil if type.nil?
-        match = type.match(/<([a-z0-9_:, ]*)>/i)
-        return [] if match.nil?
-        match[1].split(',').map(&:strip)
-      end
-    end
-  end
-end