solargraph 0.58.3 → 0.59.0.dev.1

data/lib/solargraph/pin/base.rb

@@ -41,7 +41,7 @@ module Solargraph
       # @param type_location [Solargraph::Location, nil]
       # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
-      # @param comments [String]
+      # @param comments [String, nil]
       # @param source [Symbol, nil]
       # @param docstring [YARD::Docstring, nil]
       # @param directives [::Array<YARD::Tags::Directive>, nil]
@@ -57,6 +57,9 @@ module Solargraph
         @docstring = docstring
         @directives = directives
         @combine_priority = combine_priority
+        # @type [ComplexType, ComplexType::UniqueType, nil]
+        @binder = nil
+
 
         assert_source_provided
         assert_location_provided
@@ -72,7 +75,6 @@ module Solargraph
       # @return [Pin::Closure, nil]
       def closure
         Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
-        # @type [Pin::Closure, nil]
         @closure
       end
 
@@ -81,7 +83,6 @@ module Solargraph
       #
       # @return [self]
       def combine_with(other, attrs={})
-        raise "tried to combine #{other.class} with #{self.class}" unless other.class == self.class
         priority_choice = choose_priority(other)
         return priority_choice unless priority_choice.nil?
 
@@ -92,7 +93,7 @@ module Solargraph
           location: location,
           type_location: type_location,
           name: combined_name,
-          closure: choose_pin_attr_with_same_name(other, :closure),
+          closure: combine_closure(other),
           comments: choose_longer(other, :comments),
           source: :combined,
           docstring: choose(other, :docstring),
@@ -140,14 +141,22 @@ module Solargraph
       end
 
       # @param other [self]
+      #
       # @return [::Array<YARD::Tags::Directive>, nil]
       def combine_directives(other)
         return self.directives if other.directives.empty?
         return other.directives if directives.empty?
-        [directives + other.directives].uniq
+        (directives + other.directives).uniq
+      end
+
+      # @param other [self]
+      # @return [Pin::Closure, nil]
+      def combine_closure(other)
+        choose_pin_attr_with_same_name(other, :closure)
       end
 
       # @param other [self]
+      # @sg-ignore @type should override probed type
       # @return [String]
       def combine_name(other)
         if needs_consistent_name? || other.needs_consistent_name?
@@ -170,6 +179,9 @@ module Solargraph
         # Same with @directives, @macros, @maybe_directives, which
         # regenerate docstring
         @deprecated = nil
+        @context = nil
+        @binder = nil
+        @path = nil
         reset_conversions
       end
 
@@ -189,6 +201,10 @@ module Solargraph
           other.return_type
         elsif other.return_type.undefined?
           return_type
+        elsif return_type.erased_version_of?(other.return_type)
+          other.return_type
+        elsif other.return_type.erased_version_of?(return_type)
+          return_type
         elsif dodgy_return_type_source? && !other.dodgy_return_type_source?
           other.return_type
         elsif other.dodgy_return_type_source? && !dodgy_return_type_source?
@@ -203,9 +219,12 @@ module Solargraph
         end
       end
 
+      # @sg-ignore need boolish support for ? methods
       def dodgy_return_type_source?
         # uses a lot of 'Object' instead of 'self'
-        location&.filename&.include?('core_ext/object/')
+        location&.filename&.include?('core_ext/object/') ||
+          # ditto
+          location&.filename&.include?('stdlib/date/0/date.rbs')
       end
 
       # when choices are arbitrary, make sure the choice is consistent
@@ -213,11 +232,13 @@ module Solargraph
       # @param other [Pin::Base]
       # @param attr [::Symbol]
       #
-      # @return [Object, nil]
+      # @sg-ignore
+      # @return [undefined, nil]
       def choose(other, attr)
         results = [self, other].map(&attr).compact
         # true and false are different classes and can't be sorted
         return true if results.any? { |r| r == true || r == false }
+        return results.first if results.any? { |r| r.is_a? AST::Node }
         results.min
       rescue
         STDERR.puts("Problem handling #{attr} for \n#{self.inspect}\n and \n#{other.inspect}\n\n#{self.send(attr).inspect} vs #{other.send(attr).inspect}")
@@ -250,6 +271,7 @@ module Solargraph
         end
       end
 
+      # @sg-ignore need boolish support for ? methods
       def rbs_location?
         type_location&.rbs?
       end
@@ -309,7 +331,11 @@ module Solargraph
       # @sg-ignore
       # @return [undefined]
       def assert_same(other, attr)
-        return false if other.nil?
+        if other.nil?
+          Solargraph.assert_or_log("combine_with_#{attr}_nil".to_sym,
+                                   "Other was passed in nil in assert_same on #{self}")
+          return send(attr)
+        end
         val1 = send(attr)
         val2 = other.send(attr)
         return val1 if val1 == val2
@@ -358,8 +384,11 @@ module Solargraph
           [
             # maximize number of gates, as types in other combined pins may
             # depend on those gates
+
+            # @sg-ignore Need better handling of #compact
             closure.gates.length,
             # use basename so that results don't vary system to system
+            # @sg-ignore Need better handling of #compact
             File.basename(closure.best_location.to_s)
           ]
         end
@@ -376,7 +405,7 @@ module Solargraph
       end
 
       # @param generics_to_resolve [Enumerable<String>]
-      # @param return_type_context [ComplexType, nil]
+      # @param return_type_context [ComplexType, ComplexType::UniqueType, nil]
       # @param context [ComplexType]
       # @param resolved_generic_values [Hash{String => ComplexType}]
       # @return [self]
@@ -418,6 +447,7 @@ module Solargraph
       # @return [String, nil]
       def filename
         return nil if location.nil?
+        # @sg-ignore flow sensitive typing needs to handle attrs
         location.filename
       end
 
@@ -453,11 +483,16 @@ module Solargraph
       # @return [Boolean]
       def nearly? other
         self.class == other.class &&
+          # @sg-ignore Translate to something flow sensitive typing understands
           name == other.name &&
+          # @sg-ignore flow sensitive typing needs to handle attrs
           (closure == other.closure || (closure && closure.nearly?(other.closure))) &&
+          # @sg-ignore Translate to something flow sensitive typing understands
           (comments == other.comments ||
+            # @sg-ignore Translate to something flow sensitive typing understands
             (((maybe_directives? == false && other.maybe_directives? == false) || compare_directives(directives, other.directives)) &&
-            compare_docstring_tags(docstring, other.docstring))
+             # @sg-ignore Translate to something flow sensitive typing understands
+             compare_docstring_tags(docstring, other.docstring))
           )
       end
 
@@ -484,6 +519,7 @@ module Solargraph
         @docstring ||= Solargraph::Source.parse_docstring('').to_docstring
       end
 
+      # @sg-ignore parse_comments will always set @directives
       # @return [::Array<YARD::Tags::Directive>]
       def directives
         parse_comments unless @directives
@@ -520,7 +556,7 @@ module Solargraph
       # provided ApiMap.
       #
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def typify api_map
         return_type.qualify(api_map, *(closure&.gates || ['']))
       end
@@ -528,16 +564,16 @@ module Solargraph
       # Infer the pin's return type via static code analysis.
       #
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def probe api_map
         typify api_map
       end
 
       # @deprecated Use #typify and/or #probe instead
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def infer api_map
-        Solargraph::Logging.logger.warn "WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead."
+        Solargraph.assert_or_log(:pin_infer, 'WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead.')
         type = typify(api_map)
         return type unless type.undefined?
         probe api_map
@@ -568,7 +604,7 @@ module Solargraph
       # the return type and the #proxied? setting, the proxy should be a clone
       # of the original.
       #
-      # @param return_type [ComplexType]
+      # @param return_type [ComplexType, ComplexType::UniqueType, nil]
       # @return [self]
       def proxy return_type
         result = dup
@@ -618,7 +654,7 @@ module Solargraph
 
       # @return [String]
       def inner_desc
-        closure_info = closure&.desc
+        closure_info = closure&.name.inspect
         binder_info = binder&.desc
         "name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}"
       end
@@ -646,10 +682,6 @@ module Solargraph
         end
       end
 
-      # @return [void]
-      def reset_generated!
-      end
-
       protected
 
       # @return [Boolean]
@@ -658,7 +690,7 @@ module Solargraph
       # @return [Boolean]
       attr_writer :proxied
 
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType, nil]
       attr_writer :return_type
 
       attr_writer :docstring

data/lib/solargraph/pin/base_variable.rb

@@ -6,31 +6,139 @@ module Solargraph
       # include Solargraph::Source::NodeMethods
       include Solargraph::Parser::NodeMethods
 
-      # @return [Parser::AST::Node, nil]
-      attr_reader :assignment
+      # @return [Array<Parser::AST::Node>]
+      attr_reader :assignments
 
       attr_accessor :mass_assignment
 
+      # @return [Range, nil]
+      attr_reader :presence
+
       # @param return_type [ComplexType, nil]
+      # @param assignment [Parser::AST::Node, nil] First assignment
+      #   that was made to this variable
+      # @param assignments [Array<Parser::AST::Node>] Possible
+      #   assignments that may have been made to this variable
       # @param mass_assignment [::Array(Parser::AST::Node, Integer), nil]
-      # @param assignment [Parser::AST::Node, nil]
-      def initialize assignment: nil, return_type: nil, mass_assignment: nil, **splat
+      # @param assignment [Parser::AST::Node, nil] First assignment
+      #   that was made to this variable
+      # @param assignments [Array<Parser::AST::Node>] Possible
+      #   assignments that may have been made to this variable
+      # @param exclude_return_type [ComplexType, nil] Ensure any
+      #   return type returned will never include any of these unique
+      #   types in the unique types of its complex type.
+      #
+      #   Example: If a return type is 'Float | Integer | nil' and the
+      #   exclude_return_type is 'Integer', the resulting return
+      #   type will be 'Float | nil' because Integer is excluded.
+      # @param intersection_return_type [ComplexType, nil] Ensure each unique
+      #   return type is compatible with at least one element of this
+      #   complex type.  If a ComplexType used as a return type is an
+      #   union type - we can return any of these - these are
+      #   intersection types - everything we return needs to meet at least
+      #   one of these unique types.
+      #
+      #   Example: If a return type is 'Numeric | nil' and the
+      #   intersection_return_type is 'Float | nil', the resulting return
+      #   type will be 'Float | nil' because Float is compatible
+      #   with Numeric and nil is compatible with nil.
+      # @see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types
+      # @see https://en.wikipedia.org/wiki/Intersection_type#TypeScript_example
+      # @param presence [Range, nil]
+      # @param presence_certain [Boolean]
+      def initialize assignment: nil, assignments: [], mass_assignment: nil,
+                     presence: nil, presence_certain: false, return_type: nil,
+                     intersection_return_type: nil, exclude_return_type: nil,
+                     **splat
         super(**splat)
-        @assignment = assignment
+        @assignments = (assignment.nil? ? [] : [assignment]) + assignments
         # @type [nil, ::Array(Parser::AST::Node, Integer)]
-        @mass_assignment = nil
+        @mass_assignment = mass_assignment
         @return_type = return_type
+        @intersection_return_type = intersection_return_type
+        @exclude_return_type = exclude_return_type
+        @presence = presence
+        @presence_certain = presence_certain
+      end
+
+      # @param presence [Range]
+      # @param exclude_return_type [ComplexType, nil]
+      # @param intersection_return_type [ComplexType, nil]
+      # @param source [::Symbol]
+      #
+      # @return [self]
+      def downcast presence:, exclude_return_type: nil, intersection_return_type: nil,
+                   source: self.source
+        result = dup
+        result.exclude_return_type = exclude_return_type
+        result.intersection_return_type = intersection_return_type
+        result.source = source
+        result.presence = presence
+        result.reset_generated!
+        result
+      end
+
+      def reset_generated!
+        @assignment = nil
+        super
       end
 
       def combine_with(other, attrs={})
+        new_assignments = combine_assignments(other)
         new_attrs = attrs.merge({
-          assignment: assert_same(other, :assignment),
-          mass_assignment: assert_same(other, :mass_assignment),
+          # default values don't exist in RBS parameters; it just
+          # tells you if the arg is optional or not.  Prefer a
+          # provided value if we have one here since we can't rely on
+          # it from RBS so we can infer from it and typecheck on it.
+          assignment: choose(other, :assignment),
+          assignments: new_assignments,
+          mass_assignment: combine_mass_assignment(other),
           return_type: combine_return_type(other),
+          intersection_return_type: combine_types(other, :intersection_return_type),
+          exclude_return_type: combine_types(other, :exclude_return_type),
+          presence: combine_presence(other),
+          presence_certain: combine_presence_certain(other)
         })
         super(other, new_attrs)
       end
 
+      # @param other [self]
+      #
+      # @return [Array(AST::Node, Integer), nil]
+      def combine_mass_assignment(other)
+        # @todo pick first non-nil arbitrarily - we don't yet support
+        #   mass assignment merging
+        mass_assignment || other.mass_assignment
+      end
+
+      # If a certain pin is being combined with an uncertain pin, we
+      # end up with a certain result
+      #
+      # @param other [self]
+      #
+      # @return [Boolean]
+      def combine_presence_certain(other)
+        presence_certain? || other.presence_certain?
+      end
+
+      # @return [Parser::AST::Node, nil]
+      def assignment
+        @assignment ||= assignments.last
+      end
+
+      # @param other [self]
+      #
+      # @return [::Array<Parser::AST::Node>]
+      def combine_assignments(other)
+        (other.assignments + assignments).uniq
+      end
+
+      def inner_desc
+        super + ", presence=#{presence.inspect}, assignments=#{assignments}, " \
+                "intersection_return_type=#{intersection_return_type&.rooted_tags.inspect}, " \
+                "exclude_return_type=#{exclude_return_type&.rooted_tags.inspect}"
+      end
+
       def completion_item_kind
         Solargraph::LanguageServer::CompletionItemKinds::VARIABLE
       end
@@ -40,10 +148,6 @@ module Solargraph
         Solargraph::LanguageServer::SymbolKinds::VARIABLE
       end
 
-      def return_type
-        @return_type ||= generate_complex_type
-      end
-
       def nil_assignment?
         # this will always be false - should it be return_type ==
         #   ComplexType::NIL or somesuch?
@@ -67,10 +171,12 @@ module Solargraph
             rng = Range.from_node(node)
             next if rng.nil?
             pos = rng.ending
+            # @sg-ignore Need to add nil check here
             clip = api_map.clip_at(location.filename, pos)
             # Use the return node for inference. The clip might infer from the
             # first node in a method call instead of the entire call.
             chain = Parser.chain(node, nil, nil)
+            # @sg-ignore Need to add nil check here
             result = chain.infer(api_map, closure, clip.locals).self_to_type(closure.context)
             types.push result unless result.undefined?
           end
@@ -79,13 +185,15 @@ module Solargraph
       end
 
       # @param api_map [ApiMap]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def probe api_map
-        unless @assignment.nil?
-          types = return_types_from_node(@assignment, api_map)
-          return ComplexType.new(types.uniq) unless types.empty?
-        end
+        assignment_types = assignments.flat_map { |node| return_types_from_node(node, api_map) }
+        type_from_assignment = ComplexType.new(assignment_types.flat_map(&:items).uniq) unless assignment_types.empty?
+        return adjust_type api_map, type_from_assignment unless type_from_assignment.nil?
 
+        # @todo should handle merging types from mass assignments as
+        #   well so that we can do better flow sensitive typing with
+        #   multiple assignments
         unless @mass_assignment.nil?
           mass_node, index = @mass_assignment
           types = return_types_from_node(mass_node, api_map)
@@ -96,7 +204,10 @@ module Solargraph
               type.all_params.first
             end
           end.compact!
-          return ComplexType.new(types.uniq) unless types.empty?
+
+          return ComplexType::UNDEFINED if types.empty?
+
+          return adjust_type api_map, ComplexType.new(types.uniq).qualify(api_map, *gates)
         end
 
         ComplexType::UNDEFINED
@@ -113,13 +224,194 @@ module Solargraph
         "#{super} = #{assignment&.type.inspect}"
       end
 
+      # @return [ComplexType, nil]
+      def return_type
+        generate_complex_type || @return_type || intersection_return_type || ComplexType::UNDEFINED
+      end
+
+      def typify api_map
+        raw_return_type = super
+
+        adjust_type(api_map, raw_return_type)
+      end
+
+      # @sg-ignore need boolish support for ? methods
+      def presence_certain?
+        exclude_return_type || intersection_return_type
+      end
+
+      # @param other_loc [Location]
+      # @sg-ignore flow sensitive typing needs to handle attrs
+      def starts_at?(other_loc)
+        location&.filename == other_loc.filename &&
+          presence &&
+          # @sg-ignore flow sensitive typing needs to handle attrs
+          presence.start == other_loc.range.start
+      end
+
+      # Narrow the presence range to the intersection of both.
+      #
+      # @param other [self]
+      #
+      # @return [Range, nil]
+      def combine_presence(other)
+        return presence || other.presence if presence.nil? || other.presence.nil?
+
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        Range.new([presence.start, other.presence.start].max, [presence.ending, other.presence.ending].min)
+      end
+
+      # @param other [self]
+      # @return [Pin::Closure, nil]
+      def combine_closure(other)
+        return closure if self.closure == other.closure
+
+        # choose first defined, as that establishes the scope of the variable
+        if closure.nil? || other.closure.nil?
+          Solargraph.assert_or_log(:varible_closure_missing) do
+            "One of the local variables being combined is missing a closure: " \
+              "#{self.inspect} vs #{other.inspect}"
+          end
+          return closure || other.closure
+        end
+
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        if closure.location.nil? || other.closure.location.nil?
+          # @sg-ignore flow sensitive typing needs to handle attrs
+          return closure.location.nil? ? other.closure : closure
+        end
+
+        # if filenames are different, this will just pick one
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        return closure if closure.location <= other.closure.location
+
+        other.closure
+      end
+
+      # @param other_closure [Pin::Closure]
+      # @param other_loc [Location]
+      def visible_at?(other_closure, other_loc)
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        location.filename == other_loc.filename &&
+          # @sg-ignore flow sensitive typing needs to handle attrs
+          (!presence || presence.include?(other_loc.range.start)) &&
+          visible_in_closure?(other_closure)
+      end
+
+      def presence_certain?
+        @presence_certain
+      end
+
+      protected
+
+      attr_accessor :exclude_return_type, :intersection_return_type
+
+      # @return [Range]
+      attr_writer :presence
+
       private
 
-      # @return [ComplexType]
+      # @param api_map [ApiMap]
+      # @param raw_return_type [ComplexType, ComplexType::UniqueType]
+      #
+      # @return [ComplexType, ComplexType::UniqueType]
+      def adjust_type(api_map, raw_return_type)
+        qualified_exclude = exclude_return_type&.qualify(api_map, *(closure&.gates || ['']))
+        minus_exclusions = raw_return_type.exclude qualified_exclude, api_map
+        qualified_intersection = intersection_return_type&.qualify(api_map, *(closure&.gates || ['']))
+        minus_exclusions.intersect_with qualified_intersection, api_map
+      end
+
+      # @param other [self]
+      # @return [Pin::Closure, nil]
+      def combine_closure(other)
+        return closure if self.closure == other.closure
+
+        # choose first defined, as that establishes the scope of the variable
+        if closure.nil? || other.closure.nil?
+          Solargraph.assert_or_log(:varible_closure_missing) do
+            "One of the local variables being combined is missing a closure: " \
+              "#{self.inspect} vs #{other.inspect}"
+          end
+          return closure || other.closure
+        end
+
+        # @sg-ignore Need to add nil check here
+        if closure.location.nil? || other.closure.location.nil?
+          # @sg-ignore Need to add nil check here
+          return closure.location.nil? ? other.closure : closure
+        end
+
+        # if filenames are different, this will just pick one
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        return closure if closure.location <= other.closure.location
+
+        other.closure
+      end
+
+      # See if this variable is visible within 'viewing_closure'
+      #
+      # @param viewing_closure [Pin::Closure]
+      # @return [Boolean]
+      def visible_in_closure? viewing_closure
+        return false if closure.nil?
+
+        # if we're declared at top level, we can't be seen from within
+        # methods declared tere
+
+        # @sg-ignore Need to add nil check here
+        return false if viewing_closure.is_a?(Pin::Method) && closure.context.tags == 'Class<>'
+
+        # @sg-ignore Need to add nil check here
+        return true if viewing_closure.binder.namespace == closure.binder.namespace
+
+        # @sg-ignore Need to add nil check here
+        return true if viewing_closure.return_type == closure.context
+
+        # classes and modules can't see local variables declared
+        # in their parent closure, so stop here
+        return false if scope == :instance && viewing_closure.is_a?(Pin::Namespace)
+
+        parent_of_viewing_closure = viewing_closure.closure
+
+        return false if parent_of_viewing_closure.nil?
+
+        visible_in_closure?(parent_of_viewing_closure)
+      end
+
+      # @param other [self]
+      # @return [ComplexType, nil]
+      def combine_return_type(other)
+        combine_types(other, :return_type)
+      end
+
+      # @param other [self]
+      # @param attr [::Symbol]
+      #
+      # @return [ComplexType, nil]
+      def combine_types(other, attr)
+        # @type [ComplexType, nil]
+        type1 = send(attr)
+        # @type [ComplexType, nil]
+        type2 = other.send(attr)
+        if type1 && type2
+          types = (type1.items + type2.items).uniq
+          ComplexType.new(types)
+        else
+          type1 || type2
+        end
+      end
+
+      # @return [::Symbol]
+      def scope
+        :instance
+      end
+
+      # @return [ComplexType, nil]
       def generate_complex_type
         tag = docstring.tag(:type)
         return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
-        ComplexType.new
+        nil
       end
     end
   end