solargraph 0.59.0.dev.1 → 0.59.0

data/lib/solargraph/parser/comment_ripper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ripper'
 
 module Solargraph
@@ -26,19 +28,25 @@ module Solargraph
         # @sg-ignore Need to add nil check here
         if @buffer_lines[result[2][0]][0..result[2][1]].strip =~ /^#/
           chomped = result[1].chomp
-          if result[2][0] == 0 && chomped.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '').match(/^#\s*frozen_string_literal:/)
+          if result[2][0].zero? && chomped.encode('UTF-8', 'binary', invalid: :replace, undef: :replace,
+                                                                     replace: '').match(/^#\s*frozen_string_literal:/)
             chomped = '#'
           end
-          @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+          @comments[result[2][0]] =
+            Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
         end
         result
       end
 
       # @param result [Array(Symbol, String, Array([Integer, nil], [Integer, nil]))]
       # @return [void]
-      def create_snippet(result)
+      def create_snippet result
         chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0] || 0, result[2][1] || 0, result[2][0] || 0, (result[2][1] || 0) + chomped.length), chomped)
+        @comments[result[2][0]] =
+          Snippet.new(
+            Range.from_to(result[2][0] || 0, result[2][1] || 0, result[2][0] || 0,
+                          (result[2][1] || 0) + chomped.length), chomped
+          )
       end
 
       # @sg-ignore @override is adding, not overriding

data/lib/solargraph/parser/flow_sensitive_typing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Parser
     class FlowSensitiveTyping
@@ -7,7 +9,7 @@ module Solargraph
       # @param ivars [Array<Solargraph::Pin::InstanceVariable>]
       # @param enclosing_breakable_pin [Solargraph::Pin::Breakable, nil]
       # @param enclosing_compound_statement_pin [Solargraph::Pin::CompoundStatement, nil]
-      def initialize(locals, ivars, enclosing_breakable_pin, enclosing_compound_statement_pin)
+      def initialize locals, ivars, enclosing_breakable_pin, enclosing_compound_statement_pin
         @locals = locals
         @ivars = ivars
         @enclosing_breakable_pin = enclosing_breakable_pin
@@ -19,7 +21,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_and(and_node, true_ranges = [], false_ranges = [])
+      def process_and and_node, true_ranges = [], false_ranges = []
         return unless and_node.type == :and
 
         # @type [Parser::AST::Node]
@@ -45,7 +47,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_or(or_node, true_ranges = [], false_ranges = [])
+      def process_or or_node, true_ranges = [], false_ranges = []
         return unless or_node.type == :or
 
         # @type [Parser::AST::Node]
@@ -74,7 +76,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_calls(node, true_presences, false_presences)
+      def process_calls node, true_presences, false_presences
         return unless node.type == :send
 
         process_isa(node, true_presences, false_presences)
@@ -87,7 +89,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_if(if_node, true_ranges = [], false_ranges = [])
+      def process_if if_node, true_ranges = [], false_ranges = []
         return if if_node.type != :if
 
         #
@@ -111,13 +113,9 @@ module Solargraph
           rest_of_breakable_body = Range.new(get_node_end_position(if_node),
                                              get_node_end_position(enclosing_breakable_pin.node))
 
-          if always_breaks?(then_clause)
-            false_ranges << rest_of_breakable_body
-          end
+          false_ranges << rest_of_breakable_body if always_breaks?(then_clause)
 
-          if always_breaks?(else_clause)
-            true_ranges << rest_of_breakable_body
-          end
+          true_ranges << rest_of_breakable_body if always_breaks?(else_clause)
         end
 
         unless enclosing_compound_statement_pin.node.nil?
@@ -129,13 +127,9 @@ module Solargraph
           # statement, we can assume things about the rest of the
           # compound statement
           #
-          if always_leaves_compound_statement?(then_clause)
-            false_ranges << rest_of_returnable_body
-          end
+          false_ranges << rest_of_returnable_body if always_leaves_compound_statement?(then_clause)
 
-          if always_leaves_compound_statement?(else_clause)
-            true_ranges << rest_of_returnable_body
-          end
+          true_ranges << rest_of_returnable_body if always_leaves_compound_statement?(else_clause)
         end
 
         unless then_clause.nil?
@@ -166,7 +160,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_while(while_node, true_ranges = [], false_ranges = [])
+      def process_while while_node, true_ranges = [], false_ranges = []
         return if while_node.type != :while
 
         #
@@ -210,7 +204,7 @@ module Solargraph
       # @param downcast_not_type [ComplexType, nil]
       #
       # @return [void]
-      def add_downcast_var(pin, presence:, downcast_type:, downcast_not_type:)
+      def add_downcast_var pin, presence:, downcast_type:, downcast_not_type:
         new_pin = pin.downcast(exclude_return_type: downcast_not_type,
                                intersection_return_type: downcast_type,
                                source: :flow_sensitive_typing,
@@ -228,7 +222,7 @@ module Solargraph
       # @param presences [Array<Range>]
       #
       # @return [void]
-      def process_facts(facts_by_pin, presences)
+      def process_facts facts_by_pin, presences
         #
         # Add specialized vars for the rest of the block
         #
@@ -251,7 +245,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_expression(expression_node, true_ranges, false_ranges)
+      def process_expression expression_node, true_ranges, false_ranges
         process_calls(expression_node, true_ranges, false_ranges)
         process_and(expression_node, true_ranges, false_ranges)
         process_or(expression_node, true_ranges, false_ranges)
@@ -263,7 +257,7 @@ module Solargraph
       # @return [Array(String, String), nil] Tuple of rgument to
       #   function, then receiver of function if it's a variable,
       #   otherwise nil if no simple variable receiver
-      def parse_call(call_node, method_name)
+      def parse_call call_node, method_name
         return unless call_node&.type == :send && call_node.children[1] == method_name
         # Check if conditional node follows this pattern:
         #   s(:send,
@@ -281,8 +275,7 @@ module Solargraph
         end
         # or like this:
         # (lvar :repr)
-        # @sg-ignore Need to look at Tuple#include? handling
-        variable_name = call_receiver.children[0].to_s if [:lvar, :ivar].include?(call_receiver&.type)
+        variable_name = call_receiver.children[0].to_s if %i[lvar ivar].include?(call_receiver&.type)
         return unless variable_name
 
         [call_arg, variable_name]
@@ -290,7 +283,7 @@ module Solargraph
 
       # @param isa_node [Parser::AST::Node]
       # @return [Array(String, String), nil]
-      def parse_isa(isa_node)
+      def parse_isa isa_node
         call_type_name, variable_name = parse_call(isa_node, :is_a?)
 
         return unless call_type_name
@@ -304,7 +297,7 @@ module Solargraph
       # @sg-ignore Solargraph::Parser::FlowSensitiveTyping#find_var
       #   return type could not be inferred
       # @return [Solargraph::Pin::LocalVariable, Solargraph::Pin::InstanceVariable, nil]
-      def find_var(variable_name, position)
+      def find_var variable_name, position
         if variable_name.start_with?('@')
           # @sg-ignore flow sensitive typing needs to handle attrs
           ivars.find { |ivar| ivar.name == variable_name && (!ivar.presence || ivar.presence.include?(position)) }
@@ -319,7 +312,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_isa(isa_node, true_presences, false_presences)
+      def process_isa isa_node, true_presences, false_presences
         isa_type_name, variable_name = parse_isa(isa_node)
         return if variable_name.nil? || variable_name.empty?
         # @sg-ignore Need to add nil check here
@@ -343,7 +336,7 @@ module Solargraph
 
       # @param nilp_node [Parser::AST::Node]
       # @return [Array(String, String), nil]
-      def parse_nilp(nilp_node)
+      def parse_nilp nilp_node
         parse_call(nilp_node, :nil?)
       end
 
@@ -352,7 +345,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_nilp(nilp_node, true_presences, false_presences)
+      def process_nilp nilp_node, true_presences, false_presences
         nilp_arg, variable_name = parse_nilp(nilp_node)
         return if variable_name.nil? || variable_name.empty?
         # if .nil? got an argument, move on, this isn't the situation
@@ -380,7 +373,7 @@ module Solargraph
 
       # @param bang_node [Parser::AST::Node]
       # @return [Array(String, String), nil]
-      def parse_bang(bang_node)
+      def parse_bang bang_node
         parse_call(bang_node, :!)
       end
 
@@ -389,7 +382,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_bang(bang_node, true_presences, false_presences)
+      def process_bang bang_node, true_presences, false_presences
         # pry(main)> require 'parser/current'; Parser::CurrentRuby.parse("!2")
         # => s(:send,
         #   s(:int, 2), :!)
@@ -405,7 +398,7 @@ module Solargraph
       # @param var_node [Parser::AST::Node]
       #
       # @return [String, nil] Variable name referenced
-      def parse_variable(var_node)
+      def parse_variable var_node
         return if var_node.children.length != 1
 
         var_node.children[0]&.to_s
@@ -415,8 +408,8 @@ module Solargraph
       # @param node [Parser::AST::Node]
       # @param true_presences [Array<Range>]
       # @param false_presences [Array<Range>]
-      def process_variable(node, true_presences, false_presences)
-        return unless [:lvar, :ivar, :cvar, :gvar].include?(node.type)
+      def process_variable node, true_presences, false_presences
+        return unless %i[lvar ivar cvar gvar].include?(node.type)
 
         variable_name = parse_variable(node)
         return if variable_name.nil?
@@ -443,7 +436,7 @@ module Solargraph
       # @param node [Parser::AST::Node]
       #
       # @return [String, nil]
-      def type_name(node)
+      def type_name node
         # e.g.,
         #  s(:const, nil, :Baz)
         return unless node&.type == :const
@@ -462,22 +455,17 @@ module Solargraph
 
       # @param clause_node [Parser::AST::Node, nil]
       # @sg-ignore need boolish support for ? methods
-      def always_breaks?(clause_node)
+      def always_breaks? clause_node
         clause_node&.type == :break
       end
 
       # @param clause_node [Parser::AST::Node, nil]
-      def always_leaves_compound_statement?(clause_node)
+      def always_leaves_compound_statement? clause_node
         # https://docs.ruby-lang.org/en/2.2.0/keywords_rdoc.html
-        # @sg-ignore Need to look at Tuple#include? handling
-        [:return, :raise, :next, :redo, :retry].include?(clause_node&.type)
+        %i[return raise next redo retry].include?(clause_node&.type)
       end
 
-      attr_reader :locals
-
-      attr_reader :ivars
-
-      attr_reader :enclosing_breakable_pin, :enclosing_compound_statement_pin
+      attr_reader :locals, :ivars, :enclosing_breakable_pin, :enclosing_compound_statement_pin
     end
   end
 end

data/lib/solargraph/parser/node_processor/base.rb

@@ -58,13 +58,13 @@ module Solargraph
         # @sg-ignore downcast output of Enumerable#select
         # @return [Solargraph::Pin::Breakable, nil]
         def enclosing_breakable_pin
-          pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location&.range&.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::Breakable) && pin.location&.range&.contain?(position) }.last
         end
 
         # @todo downcast output of Enumerable#select
         # @return [Solargraph::Pin::CompoundStatement, nil]
         def enclosing_compound_statement_pin
-          pins.select{|pin| pin.is_a?(Pin::CompoundStatement) && pin.location&.range&.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::CompoundStatement) && pin.location&.range&.contain?(position) }.last
         end
 
         # @param subregion [Region]
@@ -80,14 +80,14 @@ module Solargraph
 
         # @param node [Parser::AST::Node]
         # @return [Solargraph::Location]
-        def get_node_location(node)
+        def get_node_location node
           range = Parser.node_range(node)
           Location.new(region.filename, range)
         end
 
         # @param node [Parser::AST::Node]
         # @return [String, nil]
-        def comments_for(node)
+        def comments_for node
           region.source.comments_for(node)
         end
 

data/lib/solargraph/parser/node_processor.rb

@@ -43,7 +43,7 @@ module Solargraph
           pins.push Pin::Namespace.new(
             location: region.source.location,
             name: '',
-            source: :parser,
+            source: :parser
           )
         end
         return [pins, locals, ivars] unless Parser.is_ast_node?(node)

data/lib/solargraph/parser/parser_gem/class_methods.rb

@@ -34,9 +34,7 @@ module Solargraph
         # @return [::Parser::Base]
         def parser
           @parser ||= Prism::Translation::Parser.new(FlawedBuilder.new).tap do |parser|
-            # @sg-ignore Unresolved call to diagnostics on Prism::Translation::Parser
             parser.diagnostics.all_errors_are_fatal = true
-            # @sg-ignore Unresolved call to diagnostics on Prism::Translation::Parser
             parser.diagnostics.ignore_warnings      = true
           end
         end
@@ -54,7 +52,7 @@ module Solargraph
         # @param name [String]
         # @return [Array<Location>]
         def references source, name
-          if name.end_with?("=")
+          if name.end_with?('=')
             reg = /#{Regexp.escape name[0..-2]}\s*=/
             # @param code [String]
             # @param offset [Integer]
@@ -98,17 +96,17 @@ module Solargraph
 
         # @return [Source::Chain]
         def chain *args
-          NodeChainer.chain *args
+          NodeChainer.chain(*args)
         end
 
         # @return [Source::Chain]
         def chain_string *args
-          NodeChainer.load_string *args
+          NodeChainer.load_string(*args)
         end
 
         # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
         def process_node *args
-          Solargraph::Parser::NodeProcessor.process *args
+          Solargraph::Parser::NodeProcessor.process(*args)
         end
 
         # @param node [Parser::AST::Node, nil]

data/lib/solargraph/parser/parser_gem/flawed_builder.rb

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      # A custom builder for source parsers that ignores character encoding
-      # issues in literal strings.
-      #
-      class FlawedBuilder < ::Parser::Builders::Default
-        # @param token [::Parser::AST::Node]
-        # @return [String]
-        # @sg-ignore
-        def string_value(token)
-          value(token)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      # A custom builder for source parsers that ignores character encoding
+      # issues in literal strings.
+      #
+      class FlawedBuilder < ::Parser::Builders::Default
+        # @param token [::Parser::AST::Node]
+        # @return [String]
+        # @sg-ignore
+        def string_value token
+          value(token)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_chainer.rb

@@ -22,7 +22,7 @@ module Solargraph
         # @return [Source::Chain]
         def chain
           links = generate_links(@node)
-          Chain.new(links, @node, (Parser.is_ast_node?(@node) && @node.type == :splat))
+          Chain.new(links, @node, Parser.is_ast_node?(@node) && @node.type == :splat)
         end
 
         class << self
@@ -39,7 +39,7 @@ module Solargraph
           # @param starting_line [Integer]
           #
           # @return [Source::Chain]
-          def load_string(code, filename, starting_line)
+          def load_string code, filename, starting_line
             node = Parser.parse(code.sub(/\.$/, ''), filename, starting_line)
             chain = NodeChainer.new(node).chain
             chain.links.push(Chain::Link.new) if code.end_with?('.')
@@ -63,10 +63,9 @@ module Solargraph
               result.concat generate_links(n.children[0])
               result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             elsif n.children[0].nil?
-              args = []
               # @sg-ignore Need to add nil check here
-              n.children[2..-1].each do |c|
-                args.push NodeChainer.chain(c, @filename, n)
+              n.children[2..].map do |c|
+                NodeChainer.chain(c, @filename, n)
               end
               result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             else
@@ -94,13 +93,13 @@ module Solargraph
           elsif n.type == :const
             const = unpack_name(n)
             result.push Chain::Constant.new(const)
-          elsif [:lvar, :lvasgn].include?(n.type)
+          elsif %i[lvar lvasgn].include?(n.type)
             result.push Chain::Call.new(n.children[0].to_s, Location.from_node(n))
-          elsif [:ivar, :ivasgn].include?(n.type)
+          elsif %i[ivar ivasgn].include?(n.type)
             result.push Chain::InstanceVariable.new(n.children[0].to_s, n, Location.from_node(n))
-          elsif [:cvar, :cvasgn].include?(n.type)
+          elsif %i[cvar cvasgn].include?(n.type)
             result.push Chain::ClassVariable.new(n.children[0].to_s)
-          elsif [:gvar, :gvasgn].include?(n.type)
+          elsif %i[gvar gvasgn].include?(n.type)
             result.push Chain::GlobalVariable.new(n.children[0].to_s)
           elsif n.type == :or_asgn
             # @bar ||= 123 translates to:
@@ -113,13 +112,14 @@ module Solargraph
             or_link = Chain::Or.new([lhs_chain, rhs_chain])
             # this is just for a call chain, so we don't need to record the assignment
             result.push(or_link)
-          elsif [:class, :module, :def, :defs].include?(n.type)
+          elsif %i[class module def defs].include?(n.type)
             # @todo Undefined or what?
             result.push Chain::UNDEFINED_CALL
           elsif n.type == :and
             result.concat generate_links(n.children.last)
           elsif n.type == :or
-            result.push Chain::Or.new([NodeChainer.chain(n.children[0], @filename), NodeChainer.chain(n.children[1], @filename, n)])
+            result.push Chain::Or.new([NodeChainer.chain(n.children[0], @filename),
+                                       NodeChainer.chain(n.children[1], @filename, n)])
           elsif n.type == :if
             then_clause = if n.children[1]
                             NodeChainer.chain(n.children[1], @filename, n)
@@ -132,7 +132,7 @@ module Solargraph
                             Source::Chain.new([Source::Chain::Literal.new('nil', nil)], n)
                           end
             result.push Chain::If.new([then_clause, else_clause])
-          elsif [:begin, :kwbegin].include?(n.type)
+          elsif %i[begin kwbegin].include?(n.type)
             result.concat generate_links(n.children.last)
           elsif n.type == :block_pass
             block_variable_name_node = n.children[0]
@@ -140,12 +140,10 @@ module Solargraph
               # anonymous block forwarding (e.g., "&")
               # added in Ruby 3.1 - https://bugs.ruby-lang.org/issues/11256
               result.push Chain::BlockVariable.new(nil)
+            elsif block_variable_name_node.type == :sym
+              result.push Chain::BlockSymbol.new(block_variable_name_node.children[0].to_s)
             else
-              if block_variable_name_node.type == :sym
-                result.push Chain::BlockSymbol.new("#{block_variable_name_node.children[0].to_s}")
-              else
-                result.push Chain::BlockVariable.new("&#{block_variable_name_node.children[0].to_s}")
-              end
+              result.push Chain::BlockVariable.new("&#{block_variable_name_node.children[0]}")
             end
           elsif n.type == :hash
             result.push Chain::Hash.new('::Hash', n, hash_is_splatted?(n))
@@ -154,7 +152,7 @@ module Solargraph
             result.push Source::Chain::Array.new(chained_children, n)
           else
             lit = infer_literal_node_type(n)
-            result.push (lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
+            result.push(lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
           end
           result
         end
@@ -163,7 +161,9 @@ module Solargraph
         def hash_is_splatted? node
           return false unless Parser.is_ast_node?(node) && node.type == :hash
           return false unless Parser.is_ast_node?(node.children.last) && node.children.last.type == :kwsplat
-          return false if Parser.is_ast_node?(node.children.last.children[0]) && node.children.last.children[0].type == :hash
+          if Parser.is_ast_node?(node.children.last.children[0]) && node.children.last.children[0].type == :hash
+            return false
+          end
           true
         end
 
@@ -181,7 +181,7 @@ module Solargraph
         # @return [Array<Source::Chain>]
         def node_args node
           # @sg-ignore Need to add nil check here
-          node.children[2..-1].map do |child|
+          node.children[2..].map do |child|
             NodeChainer.chain(child, @filename, node)
           end
         end