solargraph 0.58.3 → 0.60.0

data/lib/solargraph/pin/local_variable.rb

@@ -3,72 +3,28 @@
 module Solargraph
   module Pin
     class LocalVariable < BaseVariable
-      # @return [Range]
-      attr_reader :presence
-
-      def presence_certain?
-        @presence_certain
-      end
+      # @param api_map [ApiMap]
+      # @return [ComplexType, ComplexType::UniqueType]
+      def probe api_map
+        if presence_certain? && return_type&.defined?
+          # flow sensitive typing has already figured out this type
+          # has been downcast - use the type it figured out
+          # @sg-ignore flow sensitive typing should support ivars
+          return adjust_type api_map, return_type.qualify(api_map, *gates)
+        end
 
-      # @param assignment [AST::Node, nil]
-      # @param presence [Range, nil]
-      # @param presence_certain [Boolean]
-      # @param splat [Hash]
-      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
-        super(**splat)
-        @assignment = assignment
-        @presence = presence
-        @presence_certain = presence_certain
+        super
       end
 
-      def combine_with(other, attrs={})
-        new_attrs = {
-          assignment: assert_same(other, :assignment),
-          presence_certain: assert_same(other, :presence_certain?),
-        }.merge(attrs)
-        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
+      def combine_with other, attrs = {}
+        # keep this as a parameter
+        return other.combine_with(self, attrs) if other.is_a?(Parameter) && !is_a?(Parameter)
 
-        super(other, new_attrs)
-      end
-
-      # @param other_closure [Pin::Closure]
-      # @param other_loc [Location]
-      def visible_at?(other_closure, other_loc)
-        location.filename == other_loc.filename &&
-          presence.include?(other_loc.range.start) &&
-          match_named_closure(other_closure, closure)
+        super
       end
 
       def to_rbs
-        (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
-      end
-
-      private
-
-      # @param tag1 [String]
-      # @param tag2 [String]
-      # @return [Boolean]
-      def match_tags tag1, tag2
-        # @todo This is an unfortunate hack made necessary by a discrepancy in
-        #   how tags indicate the root namespace. The long-term solution is to
-        #   standardize it, whether it's `Class<>`, an empty string, or
-        #   something else.
-        tag1 == tag2 ||
-          (['', 'Class<>'].include?(tag1) && ['', 'Class<>'].include?(tag2))
-      end
-
-      # @param needle [Pin::Base]
-      # @param haystack [Pin::Base]
-      # @return [Boolean]
-      def match_named_closure needle, haystack
-        return true if needle == haystack || haystack.is_a?(Pin::Block)
-        cursor = haystack
-        until cursor.nil?
-          return true if needle.path == cursor.path
-          return false if cursor.path && !cursor.path.empty?
-          cursor = cursor.closure
-        end
-        false
+        "#{name || '(anon)'} #{return_type&.to_rbs || 'untyped'}"
       end
     end
   end