solargraph 0.54.5 → 0.55.0

data/lib/solargraph/rbs_map/core_fills.rb

@@ -16,8 +16,6 @@ module Solargraph
       ].map { |k| Pin::Keyword.new(k) }
 
       MISSING = [
-        Solargraph::Pin::Method.new(name: 'tap', scope: :instance,
-                                    closure: Solargraph::Pin::Namespace.new(name: 'Object')),
         Solargraph::Pin::Method.new(name: 'class', scope: :instance,
                                     closure: Solargraph::Pin::Namespace.new(name: 'Object'), comments: '@return [::Class<self>]')
       ]
@@ -35,6 +33,15 @@ module Solargraph
         Override.method_return('Class#allocate', 'self')
       ]
 
+      # @todo I don't see any direct link in RBS to build this from -
+      #   presumably RBS is using duck typing to match interfaces
+      #   against concrete classes
+      INCLUDES = [
+        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Array'),
+                                                generic_values: ['generic<Elem>'])
+      ]
+
       # HACK: Add Errno exception classes
       errno = Solargraph::Pin::Namespace.new(name: 'Errno')
       errnos = []
@@ -44,7 +51,7 @@ module Solargraph
       end
       ERRNOS = errnos
 
-      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS
+      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS + INCLUDES
     end
   end
 end

data/lib/solargraph/source/chain/array.rb

@@ -3,8 +3,9 @@ module Solargraph
     class Chain
       class Array < Literal
         # @param children [::Array<Chain>]
-        def initialize children
-          super('::Array')
+        # @param node [Parser::AST::Node]
+        def initialize children, node
+          super('::Array', node)
           @children = children
         end
 
@@ -17,7 +18,7 @@ module Solargraph
         # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
           child_types = @children.map do |child|
-            child.infer(api_map, name_pin, locals)
+            child.infer(api_map, name_pin, locals).simplify_literals
           end
 
           type = if child_types.uniq.length == 1 && child_types.first.defined?

data/lib/solargraph/source/chain/call.rb

@@ -3,12 +3,20 @@
 module Solargraph
   class Source
     class Chain
+      #
+      # Handles both method calls and local variable references by
+      # first looking for a variable with the name 'word', then
+      # proceeding to method signature resolution if not found.
+      #
       class Call < Chain::Link
         include Solargraph::Parser::NodeMethods
 
         # @return [String]
         attr_reader :word
 
+        # @return [Location]
+        attr_reader :location
+
         # @return [::Array<Chain>]
         attr_reader :arguments
 
@@ -16,10 +24,12 @@ module Solargraph
         attr_reader :block
 
         # @param word [String]
+        # @param location [Location, nil]
         # @param arguments [::Array<Chain>]
         # @param block [Chain, nil]
-        def initialize word, arguments = [], block = nil
+        def initialize word, location = nil, arguments = [], block = nil
           @word = word
+          @location = location
           @arguments = arguments
           @block = block
           fix_block_pass
@@ -35,20 +45,21 @@ module Solargraph
         end
 
         # @param api_map [ApiMap]
-        # @param name_pin [Pin::Closure] name_pin.binder should give us the object on which 'word' will be invoked
+        # @param name_pin [Pin::Closure] name_pin.binder should give us the type of the object on which 'word' will be invoked
         # @param locals [::Array<Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin) if word == 'super'
           return yield_pins(api_map, name_pin) if word == 'yield'
           found = if head?
-            locals.select { |p| p.name == word }
+            api_map.visible_pins(locals, word, name_pin, location)
           else
             []
           end
           return inferred_pins(found, api_map, name_pin, locals) unless found.empty?
           pins = name_pin.binder.each_unique_type.flat_map do |context|
-            ns = context.namespace == '' ? '' : context.namespace_type.tag
-            api_map.get_method_stack(ns, word, scope: context.scope)
+            ns_tag = context.namespace == '' ? '' : context.namespace_type.tag
+            stack = api_map.get_method_stack(ns_tag, word, scope: context.scope)
+            [stack.first].compact
           end
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin, locals)
@@ -72,7 +83,8 @@ module Solargraph
             # use it.  If we didn't pass a block, the logic below will
             # reject it regardless
 
-            sorted_overloads = overloads.sort { |ol| ol.block? ? -1 : 1 }
+            with_block, without_block = overloads.partition(&:block?)
+            sorted_overloads = with_block + without_block
             new_signature_pin = nil
             sorted_overloads.each do |ol|
               next unless ol.arity_matches?(arguments, with_block?)
@@ -85,13 +97,9 @@ module Solargraph
                   match = ol.parameters.any?(&:restarg?)
                   break
                 end
+
                 atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context), locals)
-                # make sure we get types from up the method
-                # inheritance chain if we don't have them on this pin
-                ptype = param.typify api_map
-                # @todo Weak type comparison
-                # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
-                unless ptype.undefined? || atype.name == ptype.name || ptype.any? { |current_ptype| api_map.super_and_sub?(current_ptype.name, atype.name) } || ptype.generic? || param.restarg?
+                unless param.compatible_arg?(atype, api_map) || param.restarg?
                   match = false
                   break
                 end
@@ -108,7 +116,27 @@ module Solargraph
                 end
                 new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil, blocktype)
                 new_return_type = new_signature_pin.return_type
-                type = with_params(new_return_type.self_to_type(name_pin.context), name_pin.context).qualify(api_map, name_pin.context.namespace) if new_return_type.defined?
+                if head?
+                  # If we're at the head of the chain, we called a
+                  # method somewhere that marked itself as returning
+                  # self.  Given we didn't invoke this on an object,
+                  # this must be a method in this same class - so we
+                  # use our own self type
+                  self_type = name_pin.context
+                else
+                  # if we're past the head in the chain, whatever the
+                  # type of the lhs side is what 'self' will be in its
+                  # declaration - we can't just use the type of the
+                  # method pin, as this might be a subclass of the
+                  # place where the method is defined
+                  self_type = name_pin.binder
+                end
+                # This same logic applies to the YARD work done by
+                # 'with_params()'.
+                #
+                # qualify(), however, happens in the namespace where
+                # the docs were written - from the method pin.
+                type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, p.namespace) if new_return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
@@ -124,13 +152,14 @@ module Solargraph
             end
             p
           end
-          result.map do |pin|
-            if pin.path == 'Class#new' && name_pin.context.tag != 'Class'
-              reduced_context = name_pin.context.reduce_class_type
+          logger.debug { "Call#inferred_pins(name_pin.binder=#{name_pin.binder}, word=#{word}, pins=#{pins.map(&:desc)}, name_pin=#{name_pin}) - result=#{result}" }
+          out = result.map do |pin|
+            if pin.path == 'Class#new' && name_pin.binder.tag != 'Class'
+              reduced_context = name_pin.binder.reduce_class_type
               pin.proxy(reduced_context)
             else
               next pin if pin.return_type.undefined?
-              selfy = pin.return_type.self_to_type(name_pin.context)
+              selfy = pin.return_type.self_to_type(name_pin.binder)
               selfy == pin.return_type ? pin : pin.proxy(selfy)
             end
           end

data/lib/solargraph/source/chain/constant.rb

@@ -41,7 +41,7 @@ module Solargraph
 
         private
 
-        # @param pin [Pin::Base]
+        # @param pin [Pin::Closure]
         # @return [::Array<String>]
         def crawl_gates pin
           clos = pin

data/lib/solargraph/source/chain/hash.rb

@@ -5,9 +5,10 @@ module Solargraph
     class Chain
       class Hash < Literal
         # @param type [String]
+        # @param node [Parser::AST::Node]
         # @param splatted [Boolean]
-        def initialize type, splatted = false
-          super(type)
+        def initialize type, node, splatted = false
+          super(type, node)
           @splatted = splatted
         end
 

data/lib/solargraph/source/chain/link.rb

@@ -82,6 +82,8 @@ module Solargraph
           "#<#{self.class} - `#{self.desc}`>"
         end
 
+        include Logging
+
         protected
 
         # Mark whether this link is the head of a chain

data/lib/solargraph/source/chain/literal.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'parser'
+
 module Solargraph
   class Source
     class Chain
@@ -8,9 +10,22 @@ module Solargraph
           @word ||= "<#{@type}>"
         end
 
+        attr_reader :value
+
         # @param type [String]
-        def initialize type
+        # @param node [Parser::AST::Node, Object]
+        def initialize type, node
+          if node.is_a?(::Parser::AST::Node)
+            if node.type == :true
+              @value = true
+            elsif node.type == :false
+              @value = false
+            elsif [:int, :sym].include?(node.type)
+              @value = node.children.first
+            end
+          end
           @type = type
+          @literal_type = ComplexType.try_parse(@value.inspect)
           @complex_type = ComplexType.try_parse(type)
         end
 
@@ -20,7 +35,12 @@ module Solargraph
         end
 
         def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(@complex_type)]
+          if api_map.super_and_sub?(@complex_type.name, @literal_type.name)
+            [Pin::ProxyType.anonymous(@literal_type)]
+          else
+            # we don't support this value as a literal type
+            [Pin::ProxyType.anonymous(@complex_type)]
+          end
         end
       end
     end

data/lib/solargraph/source/chain/z_super.rb

@@ -15,7 +15,7 @@ module Solargraph
         # @param with_block [Boolean] True if the chain is inside a block
         # @param head [Boolean] True if the call is the start of its chain
         def initialize word, with_block = false
-          super(word, [], with_block)
+          super(word, nil, [], with_block)
         end
 
         # @param api_map [ApiMap]

data/lib/solargraph/source/chain.rb

@@ -39,7 +39,7 @@ module Solargraph
       @@inference_invalidation_key = nil
       @@inference_cache = {}
 
-      UNDEFINED_CALL = Chain::Call.new('<undefined>')
+      UNDEFINED_CALL = Chain::Call.new('<undefined>', nil)
       UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
 
       # @return [::Array<Source::Chain::Link>]
@@ -75,16 +75,27 @@ module Solargraph
 
       # Determine potential Pins returned by this chain of words
       #
-      # @param api_map [ApiMap]
-      # @param name_pin [Pin::Closure] the surrounding closure pin for
-      #   the statement represented by this chain for type resolution
-      #   and method pin lookup.
+      # @param api_map [ApiMap] @param name_pin [Pin::Base] A pin
+      # representing the place in which expression is evaluated (e.g.,
+      # a Method pin, or a Module or Class pin if not run within a
+      # method - both in terms of the closure around the chain, as well
+      # as the self type used for any method calls in head position.
+      #
+      #   Requirements for name_pin:
+      #
+      #     * name_pin.context: This should be a type representing the
+      #       namespace where we can look up non-local variables and
+      #       method names.  If it is a Class<X>, we will look up
+      #       :class scoped methods/variables.
       #
-      #   For method calls (Chain::Call objects) as the first element
-      #   in the chain, 'name_pin.binder' should return the
-      #   ComplexType representing the LHS / "self type" of the call.
+      #     * name_pin.binder: Used for method call lookups only
+      #       (Chain::Call links).  For method calls as the first
+      #       element in the chain, 'name_pin.binder' should be the
+      #       same as name_pin.context above.  For method calls later
+      #       in the chain (e.g., 'b' in a.b.c), it should represent
+      #       'a'.
       #
-      # @param locals [::Enumerable<Pin::LocalVariable>] Any local
+      # @param locals [::Array<Pin::LocalVariable>] Any local
       #   variables / method parameters etc visible by the statement
       #
       # @return [::Array<Pin::Base>] Pins representing possible return
@@ -101,9 +112,18 @@ module Solargraph
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
-          type = infer_first_defined(pins, working_pin, api_map, locals)
-          return [] if type.undefined?
-          working_pin = Pin::ProxyType.anonymous(type)
+          type = infer_from_definitions(pins, working_pin, api_map, locals)
+          if type.undefined?
+            logger.debug { "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) => [] - undefined type from #{link.desc}" }
+            return []
+          end
+          # We continue to use the context from the head pin, in case
+          # we need it to, for instance, provide context for a block
+          # evaluation.  However, we use the last link's return type
+          # for the binder, as this is chaining off of it, and the
+          # binder is now the lhs of the rhs we are evaluating.
+          working_pin = Pin::ProxyType.anonymous(name_pin.context, binder: type, closure: name_pin)
+          logger.debug { "Chain#define(links=#{links.map(&:desc)}, name_pin=#{name_pin.inspect}, locals=#{locals}) - after processing #{link.desc}, new working_pin=#{working_pin} with binder #{working_pin.binder}" }
         end
         links.last.last_context = working_pin
         links.last.resolve(api_map, working_pin, locals)
@@ -123,7 +143,7 @@ module Solargraph
           @@inference_invalidation_key = api_map.hash
           @@inference_cache = {}
         end
-        out = infer_uncached api_map, name_pin, locals
+        out = infer_uncached(api_map, name_pin, locals).downcast_to_literal_if_possible
         logger.debug { "Chain#infer() - caching result - cache_key_hash=#{cache_key.hash}, links.map(&:hash)=#{links.map(&:hash)}, links=#{links}, cache_key.map(&:hash) = #{cache_key.map(&:hash)}, cache_key=#{cache_key}" }
         @@inference_cache[cache_key] = out
       end
@@ -134,8 +154,14 @@ module Solargraph
       # @return [ComplexType]
       def infer_uncached api_map, name_pin, locals
         pins = define(api_map, name_pin, locals)
-        type = infer_first_defined(pins, links.last.last_context, api_map, locals)
-        maybe_nil(type)
+        if pins.empty?
+          logger.debug { "Chain#infer_uncached(links=#{links.map(&:desc)}, locals=#{locals.map(&:desc)}) => undefined - no pins" }
+          return ComplexType::UNDEFINED
+        end
+        type = infer_from_definitions(pins, links.last.last_context, api_map, locals)
+        out = maybe_nil(type)
+        logger.debug { "Chain#infer_uncached(links=#{self.links.map(&:desc)}, locals=#{locals.map(&:desc)}, name_pin=#{name_pin}, name_pin.closure=#{name_pin.closure.inspect}, name_pin.binder=#{name_pin.binder}) => #{out.rooted_tags.inspect}" }
+        out
       end
 
       # @return [Boolean]
@@ -174,6 +200,8 @@ module Solargraph
         desc
       end
 
+      include Logging
+
       private
 
       # @param pins [::Array<Pin::Base>]
@@ -181,8 +209,10 @@ module Solargraph
       # @param api_map [ApiMap]
       # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
-      def infer_first_defined pins, context, api_map, locals
-        possibles = []
+      def infer_from_definitions pins, context, api_map, locals
+        # @type [::Array<ComplexType>]
+        types = []
+        unresolved_pins = []
         # @todo this param tag shouldn't be needed to probe the type
         # @todo ...but given it is needed, typecheck should complain that it is needed
         # @param pin [Pin::Base]
@@ -200,41 +230,41 @@ module Solargraph
               #   that accepts only [Pin::Namespace] as an argument
               type = type.resolve_generics(pin.closure, context.binder)
             end
-            if type.defined?
-              possibles.push type
-              break if pin.is_a?(Pin::Method)
-            end
+            types << type
+          else
+            unresolved_pins << pin
           end
         end
-        if possibles.empty?
-          # Limit method inference recursion
-          return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
-
-          @@inference_depth += 1
-          # @param pin [Pin::Base]
-          pins.each do |pin|
-            # Avoid infinite recursion
-            next if @@inference_stack.include?(pin)
-
-            @@inference_stack.push pin
-            type = pin.probe(api_map)
-            @@inference_stack.pop
-            if type.defined?
-              possibles.push type
-              break if pin.is_a?(Pin::Method)
-            end
-          end
-          @@inference_depth -= 1
+
+        # Limit method inference recursion
+        if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
+          return ComplexType::UNDEFINED
         end
-        return ComplexType::UNDEFINED if possibles.empty?
 
-        type = if possibles.length > 1
-          # Move nil to the end by convention
-          sorted = possibles.sort { |a, _| a.tag == 'nil' ? 1 : 0 }
-          ComplexType.new(sorted.uniq)
-        else
-          ComplexType.new(possibles)
+        @@inference_depth += 1
+        # @param pin [Pin::Base]
+        unresolved_pins.each do |pin|
+          # Avoid infinite recursion
+          if @@inference_stack.include?(pin.identity)
+            next
+          end
+
+          @@inference_stack.push(pin.identity)
+          type = pin.probe(api_map)
+          @@inference_stack.pop
+          types.push type if type
         end
+        @@inference_depth -= 1
+
+        type = if types.empty?
+                 ComplexType::UNDEFINED
+               elsif types.length > 1
+                 # Move nil to the end by convention
+                 sorted = types.flat_map(&:items).sort { |a, _| a.tag == 'nil' ? 1 : 0 }
+                 ComplexType.new(sorted.uniq)
+               else
+                 ComplexType.new(types)
+               end
         return type if context.nil? || context.return_type.undefined?
 
         type.self_to_type(context.return_type)

data/lib/solargraph/source/source_chainer.rb

@@ -32,8 +32,8 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         # Special handling for files that end with an integer and a period
-        return Chain.new([Chain::Literal.new('Integer'), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
-        return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
+        return Chain.new([Chain::Literal.new('Symbol', phrase[1..].to_sym)]) if phrase.start_with?(':') && !phrase.start_with?('::')
         return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
         begin
           return Chain.new([]) if phrase.end_with?('..')

data/lib/solargraph/source_map/clip.rb

@@ -11,7 +11,9 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
-        block.rebind(api_map) if block.is_a?(Pin::Block)
+        block_pin = block
+        block_pin.rebind(api_map) if block_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(block_pin.receiver).contain?(cursor.range.start)
+        @in_block = nil
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position

data/lib/solargraph/type_checker/checks.rb

@@ -50,6 +50,8 @@ module Solargraph
       # @param inferred [ComplexType]
       # @return [Boolean]
       def any_types_match? api_map, expected, inferred
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         # walk through the union expected type and see if any members
         # of the union match the inferred type
@@ -71,6 +73,8 @@ module Solargraph
       # @param expected [ComplexType]
       # @return [Boolean]
       def all_types_match? api_map, inferred, expected
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         inferred.each do |inf|
           next if inf.duck_type?

data/lib/solargraph/type_checker.rb

@@ -470,12 +470,22 @@ module Solargraph
     # @param pin [Pin::Method]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
     def param_hash(pin)
-      tags = pin.docstring.tags(:param)
-      return {} if tags.empty?
       # @type [Hash{String => Hash{Symbol => String, ComplexType}}]
       result = {}
+      pin.parameters.each do |param|
+        type = param.typify(api_map)
+        next if type.nil? || type.undefined?
+        result[param.name.to_s] = {
+          tagged: type.tags,
+          qualified: type
+        }
+      end
+      # see if we have additional tags to pay attention to from YARD -
+      # e.g., kwargs in a **restkwargs splat
+      tags = pin.docstring.tags(:param)
       tags.each do |tag|
-        next if tag.types.nil? || tag.types.empty?
+        next if result.key? tag.name.to_s
+        next if tag.types.nil?
         result[tag.name.to_s] = {
           tagged: tag.types.join(', '),
           qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
@@ -487,11 +497,27 @@ module Solargraph
     # @param pins [Array<Pin::Method>]
     # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
     def first_param_hash(pins)
-      pins.each do |pin|
-        result = param_hash(pin)
-        return result unless result.empty?
+      return {} if pins.empty?
+      first_pin_type = pins.first.typify(api_map)
+      first_pin = pins.first.proxy first_pin_type
+      param_names = first_pin.parameter_names
+      results = param_hash(first_pin)
+      pins[1..].each do |pin|
+        # @todo this assignment from parametric use of Hash should not lose its generic
+        # @type [Hash{String => Hash{Symbol => BasicObject}}]
+
+        # documentation of types in superclasses should fail back to
+        # subclasses if the subclass hasn't documented something
+        superclass_results = param_hash(pin)
+        superclass_results.each do |param_name, details|
+          next unless param_names.include?(param_name)
+
+          results[param_name] ||= {}
+          results[param_name][:tagged] ||= details[:tagged]
+          results[param_name][:qualified] ||= details[:qualified]
+        end
       end
-      {}
+      results
     end
 
     # @param pin [Pin::Base]
@@ -584,7 +610,8 @@ module Solargraph
                   kwargs.delete param.name.to_sym
                   settled_kwargs += 1
                 elsif param.decl == :kwarg
-                  return [] if arguments.last.links.last.is_a?(Solargraph::Source::Chain::Hash) && arguments.last.links.last.splatted?
+                  last_arg_last_link = arguments.last.links.last
+                  return [] if last_arg_last_link.is_a?(Solargraph::Source::Chain::Hash) && last_arg_last_link.splatted?
                   return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
                 end
               end

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.54.5'
+  VERSION = '0.55.0'
 end

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -16,29 +16,55 @@ module Solargraph
         def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
-            gates: [code_object.namespace.to_s]
+            gates: [code_object.namespace.to_s],
+            type: code_object.namespace.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
+            source: :yardoc,
           )
           location = object_location(code_object, spec)
           name ||= code_object.name.to_s
           return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
-          pin = Pin::Method.new(
-            location: location,
-            closure: closure,
-            name: name,
-            comments: comments,
-            scope: scope || code_object.scope,
-            visibility: visibility || code_object.visibility,
-            # @todo Might need to convert overloads to signatures
-            parameters: [],
-            explicit: code_object.is_explicit?,
-            return_type: return_type
-          )
-          pin.parameters.concat get_parameters(code_object, location, comments, pin)
+          final_scope = scope || code_object.scope
+          final_visibility = visibility || code_object.visibility
+          if code_object.is_alias?
+            origin_code_object = code_object.namespace.aliases[code_object]
+            pin = Pin::MethodAlias.new(
+              name: name,
+              location: location,
+              original: origin_code_object.name.to_s,
+              closure: closure,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              parameters: [],
+              source: :yardoc,
+            )
+          else
+            pin = Pin::Method.new(
+              location: location,
+              closure: closure,
+              name: name,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              # @todo Might need to convert overloads to signatures
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              attribute: code_object.is_attribute?,
+              parameters: [],
+              source: :yardoc,
+            )
+            pin.parameters.concat get_parameters(code_object, location, comments, pin)
+          end
+          logger.debug { "ToMethod.make: Just created method pin: #{pin.inspect}" }
           pin
         end
 
         class << self
+          include Logging
+
           private
 
           # @param code_object [YARD::CodeObjects::Base]
@@ -59,7 +85,8 @@ module Solargraph
                 name: arg_name(a),
                 presence: nil,
                 decl: arg_type(a),
-                asgn_code: a[1]
+                asgn_code: a[1],
+                source: :yardoc,
               )
             end
           end