solargraph 0.54.0 → 0.58.0

data/lib/solargraph/source_map.rb

@@ -4,40 +4,53 @@ require 'yard'
 require 'solargraph/yard_tags'
 
 module Solargraph
-  # An index of pins and other ApiMap-related data for a Source.
+  # An index of Pins and other ApiMap-related data for a single Source
+  # that can be queried.
   #
   class SourceMap
     autoload :Mapper,        'solargraph/source_map/mapper'
     autoload :Clip,          'solargraph/source_map/clip'
     autoload :Completion,    'solargraph/source_map/completion'
+    autoload :Data,          'solargraph/source_map/data'
 
     # @return [Source]
     attr_reader :source
 
     # @return [Array<Pin::Base>]
-    attr_reader :pins
+    def pins
+      data.pins
+    end
+
+    # @return [Array<Pin::Base>]
+    def all_pins
+      pins + convention_pins
+    end
 
     # @return [Array<Pin::LocalVariable>]
-    attr_reader :locals
+    def locals
+      data.locals
+    end
 
     # @param source [Source]
-    # @param pins [Array<Pin::Base>]
-    # @param locals [Array<Pin::Base>]
-    def initialize source, pins, locals
-      # HACK: Keep the library from changing this
-      @source = source.dup
-      @pins = pins
-      @locals = locals
-      environ.merge Convention.for_local(self) unless filename.nil?
-      self.convention_pins = environ.pins
-      @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
+    def initialize source
+      @source = source
+
+      conventions_environ.merge Convention.for_local(self) unless filename.nil?
+      # FIXME: unmemoizing the document_symbols in case it was called and memoized from any of conventions above
+      # this is to ensure that the convention_pins from all conventions are used in the document_symbols.
+      # solargraph-rails is known to use this method to get the document symbols. It should probably be removed.
+      @document_symbols = nil
+      self.convention_pins = conventions_environ.pins
+      # @type [Hash{Class<Pin::Base> => Array<Pin::Base>}]
       @pin_select_cache = {}
     end
 
-    # @param klass [Class]
-    # @return [Array<Pin::Base>]
+    # @generic T
+    # @param klass [Class<generic<T>>]
+    #
+    # @return [Array<generic<T>>]
     def pins_by_class klass
-      @pin_select_cache[klass] ||= @pin_class_hash.select { |key, _| key <= klass }.values.flatten
+      @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
 
     # A hash representing the state of the source map's API.
@@ -47,7 +60,7 @@ module Solargraph
     #
     # @return [Integer]
     def api_hash
-      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node)).hash
+      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
     end
 
     # @return [String]
@@ -66,8 +79,8 @@ module Solargraph
     end
 
     # @return [Environ]
-    def environ
-      @environ ||= Environ.new
+    def conventions_environ
+      @conventions_environ ||= Environ.new
     end
 
     # all pins except Solargraph::Pin::Reference::Reference
@@ -113,23 +126,12 @@ module Solargraph
     # @param line [Integer]
     # @param character [Integer]
     # @return [Pin::Namespace,Pin::Method,Pin::Block]
-    def locate_block_pin line, character
-      _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
+    def locate_closure_pin line, character
+      _locate_pin line, character, Pin::Closure
     end
 
-    # @param other_map [SourceMap]
-    # @return [Boolean]
-    def try_merge! other_map
-      return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
-      pins.each_index do |i|
-        return false unless pins[i].try_merge!(other_map.pins[i])
-      end
-      locals.each_index do |i|
-        return false unless locals[i].try_merge!(other_map.locals[i])
-      end
-      @source = other_map.source
-      true
-    end
+    # @deprecated Please use locate_closure_pin instead
+    alias locate_block_pin locate_closure_pin
 
     # @param name [String]
     # @return [Array<Location>]
@@ -161,27 +163,32 @@ module Solargraph
         SourceMap.map(source)
       end
 
+      # @deprecated
       # @param source [Source]
       # @return [SourceMap]
       def map source
-        result = SourceMap::Mapper.map(source)
-        new(source, *result)
+        new(source)
       end
     end
 
     private
 
     # @return [Array<Pin::Base>]
-    def convention_pins
-      @convention_pins || []
+    attr_writer :convention_pins
+
+    # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
+    def pin_class_hash
+      @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
+    end
+
+    # @return [Data]
+    def data
+      @data ||= Data.new(source)
     end
 
-    # @param pins [Array<Pin::Base>]
     # @return [Array<Pin::Base>]
-    def convention_pins=(pins)
-      # unmemoizing the document_symbols in case it was called from any of convnetions
-      @document_symbols = nil
-      @convention_pins = pins
+    def convention_pins
+      @convention_pins || []
     end
 
     # @param line [Integer]

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/param_def.rb

@@ -12,6 +12,8 @@ module Solargraph
       # @return [Symbol]
       attr_reader :type
 
+      # @param name [String]
+      # @param type [Symbol] The type of parameter, such as :req, :opt, :rest, etc.
       def initialize name, type
         @name = name
         @type = type

data/lib/solargraph/type_checker/rules.rb

@@ -9,7 +9,8 @@ module Solargraph
         normal: 0,
         typed: 1,
         strict: 2,
-        strong: 3
+        strong: 3,
+        alpha: 4
       }.freeze
 
       # @return [Symbol]
@@ -19,7 +20,8 @@ module Solargraph
       attr_reader :rank
 
       # @param level [Symbol]
-      def initialize level
+      # @param overrides [Hash{Symbol => Symbol}]
+      def initialize level, overrides
         @rank = if LEVELS.key?(level)
           LEVELS[level]
         else
@@ -27,30 +29,55 @@ module Solargraph
           0
         end
         @level = LEVELS[LEVELS.values.index(@rank)]
+        @overrides = overrides
       end
 
       def ignore_all_undefined?
-        rank < LEVELS[:strict]
+        !report_undefined?
+      end
+
+      def report_undefined?
+        report?(:report_undefined, :strict)
       end
 
       def validate_consts?
-        rank >= LEVELS[:strict]
+        report?(:validate_consts, :strict)
       end
 
       def validate_calls?
-        rank >= LEVELS[:strict]
+        report?(:validate_calls, :strict)
       end
 
       def require_type_tags?
-        rank >= LEVELS[:strong]
+        report?(:validate_type_tags, :strong)
       end
 
       def must_tag_or_infer?
-        rank > LEVELS[:typed]
+        report?(:must_tag_or_infer, :strict)
       end
 
       def validate_tags?
-        rank > LEVELS[:normal]
+        report?(:validate_tags, :typed)
+      end
+
+      def require_all_return_types_match_inferred?
+        report?(:require_all_return_types_match_inferred, :alpha)
+      end
+
+      # We keep this at strong because if you added an @ sg-ignore to
+      # address a strong-level issue, then ran at a lower level, you'd
+      # get a false positive - we don't run stronger level checks than
+      # requested for performance reasons
+      def validate_sg_ignores?
+        report?(:validate_sg_ignores, :strong)
+      end
+
+      private
+
+      # @param type [Symbol]
+      # @param level [Symbol]
+      def report?(type, level)
+        rank >= LEVELS[@overrides.fetch(type, level)]
       end
     end
   end