solargraph 0.56.2 → 0.58.0

data/lib/solargraph/source/cursor.rb

@@ -35,7 +35,6 @@ module Solargraph
       # The part of the word before the current position. Given the text
       # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
       #
-      # @sg-ignore Improve resolution of String#match below
       # @return [String]
       def start_of_word
         @start_of_word ||= begin
@@ -125,7 +124,7 @@ module Solargraph
       def node_position
         @node_position ||= begin
           if start_of_word.empty?
-            match = source.code[0, offset].match(/[\s]*(\.|:+)[\s]*$/)
+            match = source.code[0, offset].match(/\s*(\.|:+)\s*$/)
             if match
               Position.from_offset(source.code, offset - match[0].length)
             else
@@ -160,7 +159,7 @@ module Solargraph
       #
       # @return [Regexp]
       def end_word_pattern
-        /^([a-z0-9_]|[^\u0000-\u007F])*[\?\!]?/i
+        /^([a-z0-9_]|[^\u0000-\u007F])*[?!]?/i
       end
     end
   end

data/lib/solargraph/source/source_chainer.rb

@@ -97,7 +97,7 @@ module Solargraph
       # @return [String]
       def end_of_phrase
         @end_of_phrase ||= begin
-          match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
+          match = phrase.match(/\s*(\.{1}|::)\s*$/)
           if match
             match[0]
           else

data/lib/solargraph/source.rb

@@ -15,7 +15,7 @@ module Solargraph
 
     include EncodingFixes
 
-    # @return [String]
+    # @return [String, nil]
     attr_reader :filename
 
     # @return [String]
@@ -30,7 +30,7 @@ module Solargraph
       @node
     end
 
-    # @return [Hash{Integer => Array<String>}]
+    # @return [Hash{Integer => Solargraph::Parser::Snippet}]
     def comments
       finalize
       @comments
@@ -235,6 +235,7 @@ module Solargraph
     # @return [Hash{Integer => String}]
     def associated_comments
       @associated_comments ||= begin
+        # @type [Hash{Integer => String}]
         result = {}
         buffer = String.new('')
         # @type [Integer, nil]
@@ -317,7 +318,7 @@ module Solargraph
       @string_nodes ||= string_nodes_in(node)
     end
 
-    # @return [Array<Range>]
+    # @return [Array<Solargraph::Range>]
     def comment_ranges
       @comment_ranges ||= comments.values.map(&:range)
     end
@@ -386,6 +387,7 @@ module Solargraph
     # @return [Integer]
     attr_writer :version
 
+    # @return [void]
     def finalize
       return if @finalized && changes.empty?
 
@@ -440,6 +442,7 @@ module Solargraph
     # @return [String]
     attr_writer :repaired
 
+    # @return [String]
     def repaired
       finalize
       @repaired

data/lib/solargraph/source_map/clip.rb

@@ -11,15 +11,14 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
-        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
+        closure_pin = closure
+        closure_pin.rebind(api_map) if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
       def define
         return [] if cursor.comment? || cursor.chain.literal?
-        result = cursor.chain.define(api_map, block, locals)
+        result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
         result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
         result
@@ -51,43 +50,36 @@ module Solargraph
 
       # @return [ComplexType]
       def infer
-        result = cursor.chain.infer(api_map, block, locals)
+        result = cursor.chain.infer(api_map, closure, locals)
         if result.tag == 'Class'
           # HACK: Exception to return BasicObject from Class#new
-          dfn = cursor.chain.define(api_map, block, locals).first
+          dfn = cursor.chain.define(api_map, closure, locals).first
           return ComplexType.try_parse('::BasicObject') if dfn && dfn.path == 'Class#new'
         end
-        return result unless result.tag == 'self'
-        cursor.chain.base.infer(api_map, block, locals)
+        # should receive result with selfs resolved from infer()
+        Solargraph.assert_or_log(:clip_infer_self, 'Received selfy inference') if result.selfy?
+        result
       end
 
       # Get an array of all the locals that are visible from the cursors's
       # position. Locals can be local variables, method parameters, or block
       # parameters. The array starts with the nearest local pin.
       #
-      # @return [::Array<Solargraph::Pin::Base>]
+      # @return [::Array<Solargraph::Pin::LocalVariable>]
       def locals
         @locals ||= source_map.locals_at(location)
       end
 
       # @return [::Array<String>]
       def gates
-        block.gates
-      end
-
-      def in_block?
-        return @in_block unless @in_block.nil?
-        @in_block = begin
-          tree = cursor.source.tree_at(cursor.position.line, cursor.position.column)
-          Parser.is_ast_node?(tree[1]) && [:block, :ITER].include?(tree[1].type)
-        end
+        closure.gates
       end
 
       # @param phrase [String]
       # @return [Array<Solargraph::Pin::Base>]
       def translate phrase
         chain = Parser.chain(Parser.parse(phrase))
-        chain.define(api_map, block, locals)
+        chain.define(api_map, closure, locals)
       end
 
       private
@@ -109,8 +101,8 @@ module Solargraph
       end
 
       # @return [Solargraph::Pin::Closure]
-      def block
-        @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
+      def closure
+        @closure ||= source_map.locate_closure_pin(cursor.node_position.line, cursor.node_position.character)
       end
 
       # The context at the current position.
@@ -201,20 +193,20 @@ module Solargraph
             result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
           end
         else
-          type = cursor.chain.base.infer(api_map, block, locals)
-          result.concat api_map.get_complex_type_methods(type, block.binder.namespace, cursor.chain.links.length == 1)
+          type = cursor.chain.base.infer(api_map, closure, locals)
+          result.concat api_map.get_complex_type_methods(type, closure.binder.namespace, cursor.chain.links.length == 1)
           if cursor.chain.links.length == 1
             if cursor.word.start_with?('@@')
               return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
             elsif cursor.word.start_with?('@')
-              return package_completions(api_map.get_instance_variable_pins(block.binder.namespace, block.binder.scope))
+              return package_completions(api_map.get_instance_variable_pins(closure.binder.namespace, closure.binder.scope))
             elsif cursor.word.start_with?('$')
               return package_completions(api_map.get_global_variable_pins)
             end
             result.concat locals
-            result.concat file_global_methods unless block.binder.namespace.empty?
+            result.concat file_global_methods unless closure.binder.namespace.empty?
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
-            result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods(closure.binder.namespace, scope: closure.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
             result.concat api_map.keyword_pins.to_a
           end

data/lib/solargraph/source_map/data.rb

@@ -3,15 +3,18 @@
 module Solargraph
   class SourceMap
     class Data
+      # @param source [Solargraph::Source]
       def initialize source
         @source = source
       end
 
+      # @return [Array<Solargraph::Pin::Base>]
       def pins
         generate
         @pins || []
       end
 
+      # @return [Array<Solargraph::LocalVariable>]
       def locals
         generate
         @locals || []
@@ -19,6 +22,7 @@ module Solargraph
 
       private
 
+      # @return [void]
       def generate
         return if @generated
 

data/lib/solargraph/source_map/mapper.rb

@@ -163,7 +163,7 @@ module Solargraph
             end
           end
         when 'visibility'
-          begin
+
             kind = directive.tag.text&.to_sym
             return unless [:private, :protected, :public].include?(kind)
 
@@ -182,7 +182,7 @@ module Solargraph
                 pin.instance_variable_set(:@visibility, kind)
               end
             end
-          end
+
         when 'parse'
           begin
             ns = closure_at(source_position)

data/lib/solargraph/source_map.rb

@@ -21,6 +21,11 @@ module Solargraph
       data.pins
     end
 
+    # @return [Array<Pin::Base>]
+    def all_pins
+      pins + convention_pins
+    end
+
     # @return [Array<Pin::LocalVariable>]
     def locals
       data.locals
@@ -30,13 +35,20 @@ module Solargraph
     def initialize source
       @source = source
 
-      environ.merge Convention.for_local(self) unless filename.nil?
-      self.convention_pins = environ.pins
+      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
     end
@@ -67,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
@@ -114,10 +126,13 @@ 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
 
+    # @deprecated Please use locate_closure_pin instead
+    alias locate_block_pin locate_closure_pin
+
     # @param name [String]
     # @return [Array<Location>]
     def references name
@@ -158,10 +173,15 @@ module Solargraph
 
     private
 
+    # @return [Array<Pin::Base>]
+    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
@@ -171,14 +191,6 @@ module Solargraph
       @convention_pins || []
     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 conventions
-      @document_symbols = nil
-      @convention_pins = pins
-    end
-
     # @param line [Integer]
     # @param character [Integer]
     # @param klasses [Array<Class>]

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

@@ -20,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
@@ -28,34 +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?
-        rank >= LEVELS[:alpha]
+        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