solargraph 0.32.5 → 0.33.0

data/lib/solargraph/pin/base_method.rb

@@ -2,23 +2,40 @@ module Solargraph
   module Pin
     # The base class for method and attribute pins.
     #
-    class BaseMethod < Base
-      # @return [Symbol] :instance or :class
-      attr_reader :scope
-
-      # @return [Symbol] :public, :private, or :protected
+    class BaseMethod < Closure
+      # @return [::Symbol] :public, :private, or :protected
       attr_reader :visibility
 
-      def return_complex_type
-        @return_complex_type ||= generate_complex_type
+      # @param visibility [::Symbol] :public, :protected, or :private
+      def initialize visibility: :public, **splat
+        super(splat)
+        @visibility = visibility
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def path
+        @path ||= namespace.to_s + (scope == :instance ? '#' : '.') + name.to_s
       end
 
       def typify api_map
         decl = super
         return decl unless decl.undefined?
-        type = see_reference(api_map)
-        return type unless type.nil?
-        ComplexType::UNDEFINED
+        type = see_reference(api_map) || typify_from_super(api_map)
+        return type.qualify(api_map, namespace) unless type.nil?
+        name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
+      end
+
+      # @return [Array<String>]
+      def parameters
+        []
+      end
+
+      # @return [Array<String>]
+      def parameter_names
+        []
       end
 
       private
@@ -35,24 +52,35 @@ module Solargraph
       end
 
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, nil]
       def see_reference api_map
         docstring.ref_tags.each do |ref|
           next unless ref.tag_name == 'return' && ref.owner
           result = resolve_reference(ref.owner.to_s, api_map)
           return result unless result.nil?
         end
-        match = comments.match(/\(see (.*)\)/)
+        match = comments.match(/^[ \t]*\(see (.*)\)/m)
         return nil if match.nil?
         resolve_reference match[1], api_map
       end
 
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def typify_from_super api_map
+        stack = api_map.get_method_stack(namespace, name, scope: scope).reject { |pin| pin.path == path }
+        return nil if stack.empty?
+        stack.each do |pin|
+          return pin.return_type unless pin.return_type.undefined?
+        end
+        nil
+      end
+
       # @param ref [String]
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def resolve_reference ref, api_map
         parts = ref.split(/[\.#]/)
-        if parts.first.empty?
+        if parts.first.empty? || parts.one?
           path = "#{namespace}#{ref}"
         else
           fqns = api_map.qualify(parts.first, namespace)
@@ -64,11 +92,6 @@ module Solargraph
           type = pin.typify(api_map)
           return type unless type.undefined?
         end
-        pins = api_map.get_path_pins(path)
-        pins.each do |pin|
-          type = pin.typify(api_map)
-          return type unless type.undefined?
-        end
         nil
       end
     end

data/lib/solargraph/pin/base_variable.rb

@@ -3,15 +3,11 @@ module Solargraph
     class BaseVariable < Base
       include Solargraph::Source::NodeMethods
 
-      attr_reader :context
-
       attr_reader :assignment
 
-      def initialize location, namespace, name, comments, assignment, literal, context
-        super(location, namespace, name, comments)
+      def initialize assignment: nil, **splat
+        super(splat)
         @assignment = assignment
-        @literal = literal
-        @context = context
       end
 
       def signature
@@ -27,12 +23,12 @@ module Solargraph
         Solargraph::LanguageServer::SymbolKinds::VARIABLE
       end
 
-      def return_complex_type
-        @return_complex_type ||= generate_complex_type
+      def return_type
+        @return_type ||= generate_complex_type
       end
 
       def nil_assignment?
-        return_complex_type.nil?
+        return_type.nil?
       end
 
       def variable?
@@ -41,10 +37,17 @@ module Solargraph
 
       def probe api_map
         return ComplexType::UNDEFINED if @assignment.nil?
-        chain = Source::NodeChainer.chain(@assignment, filename)
-        clip = api_map.clip_at(location.filename, location.range.start)
-        locals = clip.locals - [self]
-        chain.infer(api_map, ProxyType.anonymous(context), locals)
+        types = []
+        returns_from(@assignment).each do |node|
+          chain = Source::NodeChainer.chain(node, filename)
+          next if chain.links.first.word == name
+          clip = api_map.clip_at(location.filename, location.range.start)
+          locals = clip.locals - [self]
+          result = chain.infer(api_map, closure, locals)
+          types.push result unless result.undefined?
+        end
+        return ComplexType::UNDEFINED if types.empty?
+        ComplexType.try_parse(*types.map(&:tag))
       end
 
       def == other
@@ -55,7 +58,7 @@ module Solargraph
       def try_merge! pin
         return false unless super
         @assignment = pin.assignment
-        @return_complex_type = pin.return_complex_type
+        @return_type = pin.return_type
         true
       end
 
@@ -64,7 +67,6 @@ module Solargraph
       def generate_complex_type
         tag = docstring.tag(:type)
         return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
-        return ComplexType.try_parse(@literal) unless @literal.nil?
         ComplexType.new
       end
     end

data/lib/solargraph/pin/block.rb

@@ -1,15 +1,28 @@
 module Solargraph
   module Pin
-    class Block < Base
+    class Block < Closure
       # The signature of the method that receives this block.
       #
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
-      def initialize location, namespace, name, comments, receiver, context
-        super(location, namespace, name, comments)
+      def initialize receiver: nil, args: [], **splat
+        super(splat)
         @receiver = receiver
-        @context = context
+        @parameters = args
+      end
+
+      def rebind context
+        @rebound = true
+        @binder = context unless context.undefined?
+      end
+
+      def rebound?
+        @rebound ||= false
+      end
+
+      def binder
+        @binder || context
       end
 
       def kind
@@ -21,6 +34,11 @@ module Solargraph
         @parameters ||= []
       end
 
+      # @return [Array<String>]
+      def parameter_names
+        @parameter_names ||= parameters.map{|p| p.split(/[ =:]/).first.gsub(/^(\*{1,2}|&)/, '')}
+      end
+
       def nearly? other
         return false unless super
         # @todo Trying to not to block merges too much

data/lib/solargraph/pin/closure.rb

@@ -0,0 +1,28 @@
+module Solargraph
+  module Pin
+    class Closure < Base
+      # @return [::Symbol] :class or :instance
+      attr_reader :scope
+
+      def initialize scope: :class, **splat
+        super(splat)
+        @scope = scope
+      end
+
+      def context
+        @context ||= begin
+          result = super
+          if scope == :instance
+            Solargraph::ComplexType.parse(result.namespace)
+          else
+            result
+          end
+        end
+      end
+
+      def binder
+        @binder || context
+      end
+    end
+  end
+end

data/lib/solargraph/pin/common.rb

@@ -0,0 +1,59 @@
+module Solargraph
+  module Pin
+    module Common
+      attr_reader :location
+
+      # @return [Pin::Base, nil]
+      attr_reader :closure
+
+      # @return [String]
+      def name
+        @name ||= ''
+      end
+
+      def kind
+        @kind ||= Pin::KEYWORD
+      end
+
+      def return_type
+        @return_type ||= ComplexType::UNDEFINED
+      end
+
+      # @return [ComplexType]
+      def context
+        # Get the static context from the nearest namespace
+        @context ||= find_context
+      end
+      alias full_context context
+
+      def namespace
+        context.namespace.to_s
+      end
+
+      # @return [ComplexType]
+      def binder
+        @binder || context
+      end
+
+      def comments
+        @comments ||= ''
+      end
+
+      def path
+        @path ||= name.empty? ? context.namespace : "#{context.namespace}::#{name}"
+      end
+
+      private
+
+      # @return [ComplexType]
+      def find_context
+        here = closure
+        until here.nil?
+          return here.return_type if here.kind == Pin::NAMESPACE
+          here = here.closure
+        end
+        ComplexType::ROOT
+      end
+    end
+  end
+end

data/lib/solargraph/pin/constant.rb

@@ -3,8 +3,8 @@ module Solargraph
     class Constant < BaseVariable
       attr_reader :visibility
 
-      def initialize location, namespace, name, comments, assignment, literal, context, visibility
-        super(location, namespace, name, comments, assignment, literal, context)
+      def initialize visibility: :public, **splat
+        super(splat)
         @visibility = visibility
       end
 
@@ -22,8 +22,8 @@ module Solargraph
       end
 
       def path
-        return name if namespace.empty?
-        "#{namespace}::#{name}"
+        return name if context.namespace.to_s.empty?
+        "#{context.namespace}::#{name}"
       end
     end
   end

data/lib/solargraph/pin/conversions.rb

@@ -41,14 +41,14 @@ module Solargraph
 
       # @return [String]
       def detail
-        if @detail.nil?
-          @detail = ''
-          @detail += "(#{parameters.join(', ')}) " unless kind != Pin::METHOD or parameters.empty?
-          @detail += "=> #{return_complex_type}" unless return_complex_type.undefined?
-          @detail.strip!
-        end
-        return nil if @detail.empty?
-        @detail
+        # This property is not cached in an instance variable because it can
+        # change when pins get proxied.
+        detail = ''
+        detail += "(#{parameters.join(', ')}) " unless kind != Pin::METHOD or parameters.empty?
+        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type}" unless return_type.undefined?
+        detail.strip!
+        return nil if detail.empty?
+        detail
       end
 
       # Get a markdown-flavored link to a documentation page.

data/lib/solargraph/pin/duck_method.rb

@@ -6,9 +6,9 @@ module Solargraph
     class DuckMethod < Pin::Method
       # @param location [Solargraph::Location]
       # @param name [String]
-      def initialize location, name
-        super(location, '', name, nil, :instance, :public, [])
-      end
+      # def initialize location, name
+      #   # super(location, '', name, nil, :instance, :public, [])
+      # end
     end
   end
 end

data/lib/solargraph/pin/instance_variable.rb

@@ -4,6 +4,36 @@ module Solargraph
       def kind
         Pin::INSTANCE_VARIABLE
       end
+
+      def binder
+        closure.binder
+      end
+
+      def scope
+        closure.binder.scope
+      end
+
+      def context
+        @context ||= begin
+          result = super
+          if scope == :class
+            ComplexType.parse("Class<#{result.namespace}>")
+          else
+            ComplexType.parse("#{result.namespace}")
+          end
+        end
+      end
+
+      def nearly? other
+        super && binder == other.binder
+      end
+
+      def try_merge! pin
+        return false unless super
+        @assignment = pin.assignment
+        @return_type = pin.return_type
+        true
+      end
     end
   end
 end

data/lib/solargraph/pin/keyword.rb

@@ -2,7 +2,7 @@ module Solargraph
   module Pin
     class Keyword < Base
       def initialize name
-        @name = name
+        super(name: name)
       end
 
       def name

data/lib/solargraph/pin/local_variable.rb

@@ -3,9 +3,9 @@ module Solargraph
     class LocalVariable < BaseVariable
       include Localized
 
-      def initialize location, namespace, name, comments, assignment, literal, context, block, presence
-        super(location, namespace, name, comments, assignment, literal, context)
-        @block = block
+      def initialize assignment: nil, presence: nil, **splat
+        super(splat)
+        @assignment = assignment
         @presence = presence
       end
 

data/lib/solargraph/pin/localized.rb

@@ -1,8 +1,6 @@
 module Solargraph
   module Pin
     module Localized
-      attr_reader :block
-
       # @return [Range]
       attr_reader :presence
 
@@ -12,11 +10,17 @@ module Solargraph
       def visible_from?(other, position)
         position = Position.normalize(position)
         other.filename == filename and
-          ( other == block or 
-            (block.location.range.contain?(other.location.range.start) and block.location.range.contain?(other.location.range.ending))
-          ) and
+          (other == closure ||
+            (closure.location.range.contain?(closure.location.range.start) && closure.location.range.contain?(other.location.range.ending))
+          ) &&
           presence.contain?(position)
       end
+
+      # @param other_loc [Location]
+      def visible_at?(other_loc)
+        return false if location.filename != other_loc.filename
+        presence.include?(other_loc.range.start)
+      end
     end
   end
 end