solargraph 0.54.4 → 0.55.0

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

@@ -57,22 +57,22 @@ module Solargraph
           elsif n.type == :send
             if n.children[0].is_a?(::Parser::AST::Node)
               result.concat generate_links(n.children[0])
-              result.push Chain::Call.new(n.children[1].to_s, node_args(n), passed_block(n))
+              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 = []
               n.children[2..-1].each do |c|
                 args.push NodeChainer.chain(c, @filename, n)
               end
-              result.push Chain::Call.new(n.children[1].to_s, node_args(n), passed_block(n))
+              result.push Chain::Call.new(n.children[1].to_s, Location.from_node(n), node_args(n), passed_block(n))
             else
               raise "No idea what to do with #{n}"
             end
           elsif n.type == :csend
             if n.children[0].is_a?(::Parser::AST::Node)
               result.concat generate_links(n.children[0])
-              result.push Chain::QCall.new(n.children[1].to_s, node_args(n))
+              result.push Chain::QCall.new(n.children[1].to_s, Location.from_node(n), node_args(n))
             elsif n.children[0].nil?
-              result.push Chain::QCall.new(n.children[1].to_s, node_args(n))
+              result.push Chain::QCall.new(n.children[1].to_s, Location.from_node(n), node_args(n))
             else
               raise "No idea what to do with #{n}"
             end
@@ -82,15 +82,15 @@ module Solargraph
             result.push Chain::ZSuper.new('super')
           elsif n.type == :super
             args = n.children.map { |c| NodeChainer.chain(c, @filename, n) }
-            result.push Chain::Call.new('super', args)
+            result.push Chain::Call.new('super', Location.from_node(n), args)
           elsif n.type == :yield
             args = n.children.map { |c| NodeChainer.chain(c, @filename, n) }
-            result.push Chain::Call.new('yield', args)
+            result.push Chain::Call.new('yield', Location.from_node(n), args)
           elsif n.type == :const
             const = unpack_name(n)
             result.push Chain::Constant.new(const)
           elsif [:lvar, :lvasgn].include?(n.type)
-            result.push Chain::Call.new(n.children[0].to_s)
+            result.push Chain::Call.new(n.children[0].to_s, Location.from_node(n))
           elsif [:ivar, :ivasgn].include?(n.type)
             result.push Chain::InstanceVariable.new(n.children[0].to_s)
           elsif [:cvar, :cvasgn].include?(n.type)
@@ -124,13 +124,13 @@ module Solargraph
               end
             end
           elsif n.type == :hash
-            result.push Chain::Hash.new('::Hash', hash_is_splatted?(n))
+            result.push Chain::Hash.new('::Hash', n, hash_is_splatted?(n))
           elsif n.type == :array
             chained_children = n.children.map { |c| NodeChainer.chain(c) }
-            result.push Source::Chain::Array.new(chained_children)
+            result.push Source::Chain::Array.new(chained_children, n)
           else
             lit = infer_literal_node_type(n)
-            result.push (lit ? Chain::Literal.new(lit) : Chain::Link.new)
+            result.push (lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
           end
           result
         end

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

@@ -40,7 +40,7 @@ module Solargraph
               if n.is_a?(AST::Node)
                 if n.type == :cbase
                   parts = [''] + pack_name(n)
-                else
+                elsif n.type == :const
                   parts += pack_name(n)
                 end
               else
@@ -59,6 +59,8 @@ module Solargraph
             return '::String'
           elsif node.type == :array
             return '::Array'
+          elsif node.type == :nil
+            return '::NilClass'
           elsif node.type == :hash
             return '::Hash'
           elsif node.type == :int

data/lib/solargraph/parser/parser_gem/node_processors/and_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class AndNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            process_children
+
+            position = get_node_start_position(node)
+            enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
+            FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_and(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/casgn_node.rb

@@ -8,6 +8,17 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
+            if Convention::StructDefinition::StructAssignmentNode.valid?(node)
+              process_struct_assignment
+            else
+              process_constant_assignment
+            end
+          end
+
+          private
+
+          # @return [void]
+          def process_constant_assignment
             pins.push Solargraph::Pin::Constant.new(
               location: get_node_location(node),
               closure: region.closure,
@@ -18,7 +29,16 @@ module Solargraph
             process_children
           end
 
-          private
+          # TODO: Move this out of [CasgnNode] once [Solargraph::Parser::NodeProcessor] supports
+          # multiple processors.
+          def process_struct_assignment
+            processor_klass = Convention::StructDefinition::NodeProcessors::StructNode
+            processor = processor_klass.new(node, region, pins, locals)
+            processor.process
+
+            @pins = processor.pins
+            @locals = processor.locals
+          end
 
           # @return [String]
           def const_name

data/lib/solargraph/parser/parser_gem/node_processors/if_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class IfNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            process_children
+
+            position = get_node_start_position(node)
+            enclosing_breakable_pin = pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location.range.contain?(position)}.last
+            FlowSensitiveTyping.new(locals, enclosing_breakable_pin).process_if(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/namespace_node.rb

@@ -8,10 +8,20 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            sc = nil
-            if node.type == :class and !node.children[1].nil?
-              sc = unpack_name(node.children[1])
+            superclass_name = nil
+            superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
+
+            if Convention::StructDefinition::StructDefintionNode.valid?(node)
+              process_struct_definition
+            else
+              process_namespace(superclass_name)
             end
+          end
+
+          private
+
+          # @param superclass_name [String, nil]
+          def process_namespace(superclass_name)
             loc = get_node_location(node)
             nspin = Solargraph::Pin::Namespace.new(
               type: node.type,
@@ -23,15 +33,26 @@ module Solargraph
               gates: region.closure.gates.freeze
             )
             pins.push nspin
-            unless sc.nil?
+            unless superclass_name.nil?
               pins.push Pin::Reference::Superclass.new(
                 location: loc,
                 closure: pins.last,
-                name: sc
+                name: superclass_name
               )
             end
             process_children region.update(closure: nspin, visibility: :public)
           end
+
+          # TODO: Move this out of [NamespaceNode] once [Solargraph::Parser::NodeProcessor] supports
+          # multiple processors.
+          def process_struct_definition
+            processor_klass = Convention::StructDefinition::NodeProcessors::StructNode
+            processor = processor_klass.new(node, region, pins, locals)
+            processor.process
+
+            @pins = processor.pins
+            @locals = processor.locals
+          end
         end
       end
     end

data/lib/solargraph/parser/parser_gem/node_processors/opasgn_node.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'parser'
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class OpasgnNode < Parser::NodeProcessor::Base
+          def process
+            # Parser::CurrentRuby.parse("a += 2")
+            # => s(:op_asgn,
+            #      s(:lvasgn, :a), :+,
+            #      s(:int, 2))
+            asgn = node.children[0]
+            variable_name = asgn.children[0]
+            operator = node.children[1]
+            argument = node.children[2]
+            # for lvasgn, gvasgn, cvasgn, convert to lvar, gvar, cvar
+            # [6] pry(main)> Parser::CurrentRuby.parse("a = a + 1")
+            # => s(:lvasgn, :a,
+            #   s(:send,
+            #     s(:lvar, :a), :+,
+            #     s(:int, 1)))
+            # [7] pry(main)>
+            variable_reference_type = asgn.type.to_s.sub(/vasgn$/, 'var').to_sym
+            variable_reference = node.updated(variable_reference_type, asgn.children)
+            send_children = [
+              variable_reference,
+              operator,
+              argument
+            ]
+            send_node = node.updated(:send, send_children)
+            new_asgn = node.updated(asgn.type, [variable_name,  send_node])
+            NodeProcessor.process(new_asgn, region, pins, locals)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/until_node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class UntilNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            location = get_node_location(node)
+            # Note - this should not be considered a block, as the
+            # until statement doesn't create a closure - e.g.,
+            # variables created inside can be seen from outside as
+            # well
+            pins.push Solargraph::Pin::Until.new(
+              location: location,
+              closure: region.closure,
+              node: node,
+              comments: comments_for(node),
+            )
+            process_children region
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/while_node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class WhileNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            location = get_node_location(node)
+            # Note - this should not be considered a block, as the
+            # while statement doesn't create a closure - e.g.,
+            # variables created inside can be seen from outside as
+            # well
+            pins.push Solargraph::Pin::While.new(
+              location: location,
+              closure: region.closure,
+              node: node,
+              comments: comments_for(node),
+            )
+            process_children region
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,7 @@ module Solargraph
         autoload :NamespaceNode, 'solargraph/parser/parser_gem/node_processors/namespace_node'
         autoload :SclassNode,    'solargraph/parser/parser_gem/node_processors/sclass_node'
         autoload :IvasgnNode,    'solargraph/parser/parser_gem/node_processors/ivasgn_node'
+        autoload :IfNode,        'solargraph/parser/parser_gem/node_processors/if_node'
         autoload :CvasgnNode,    'solargraph/parser/parser_gem/node_processors/cvasgn_node'
         autoload :LvasgnNode,    'solargraph/parser/parser_gem/node_processors/lvasgn_node'
         autoload :GvasgnNode,    'solargraph/parser/parser_gem/node_processors/gvasgn_node'
@@ -22,8 +23,12 @@ module Solargraph
         autoload :ArgsNode,      'solargraph/parser/parser_gem/node_processors/args_node'
         autoload :BlockNode,     'solargraph/parser/parser_gem/node_processors/block_node'
         autoload :OrasgnNode,    'solargraph/parser/parser_gem/node_processors/orasgn_node'
+        autoload :OpasgnNode,    'solargraph/parser/parser_gem/node_processors/opasgn_node'
         autoload :SymNode,       'solargraph/parser/parser_gem/node_processors/sym_node'
         autoload :ResbodyNode,   'solargraph/parser/parser_gem/node_processors/resbody_node'
+        autoload :UntilNode,     'solargraph/parser/parser_gem/node_processors/until_node'
+        autoload :WhileNode,     'solargraph/parser/parser_gem/node_processors/while_node'
+        autoload :AndNode,       'solargraph/parser/parser_gem/node_processors/and_node'
       end
     end
 
@@ -35,6 +40,7 @@ module Solargraph
       register :resbody,      ParserGem::NodeProcessors::ResbodyNode
       register :def,          ParserGem::NodeProcessors::DefNode
       register :defs,         ParserGem::NodeProcessors::DefsNode
+      register :if,           ParserGem::NodeProcessors::IfNode
       register :send,         ParserGem::NodeProcessors::SendNode
       register :class,        ParserGem::NodeProcessors::NamespaceNode
       register :module,       ParserGem::NodeProcessors::NamespaceNode
@@ -50,7 +56,11 @@ module Solargraph
       register :forward_args, ParserGem::NodeProcessors::ArgsNode
       register :block,        ParserGem::NodeProcessors::BlockNode
       register :or_asgn,      ParserGem::NodeProcessors::OrasgnNode
+      register :op_asgn,      ParserGem::NodeProcessors::OpasgnNode
       register :sym,          ParserGem::NodeProcessors::SymNode
+      register :until,        ParserGem::NodeProcessors::UntilNode
+      register :while,        ParserGem::NodeProcessors::WhileNode
+      register :and,          ParserGem::NodeProcessors::AndNode
     end
   end
 end

data/lib/solargraph/parser.rb

@@ -4,6 +4,7 @@ module Solargraph
     autoload :ParserGem, 'solargraph/parser/parser_gem'
     autoload :Region, 'solargraph/parser/region'
     autoload :NodeProcessor, 'solargraph/parser/node_processor'
+    autoload :FlowSensitiveTyping, 'solargraph/parser/flow_sensitive_typing'
     autoload :Snippet, 'solargraph/parser/snippet'
 
     class SyntaxError < StandardError

data/lib/solargraph/pin/base.rb

@@ -27,17 +27,23 @@ module Solargraph
       # @return [::Symbol]
       attr_accessor :source
 
+      def presence_certain?
+        true
+      end
+
       # @param location [Solargraph::Location, nil]
       # @param type_location [Solargraph::Location, nil]
       # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
-      def initialize location: nil, type_location: nil, closure: nil, name: '', comments: ''
+      def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: ''
         @location = location
         @type_location = type_location
         @closure = closure
         @name = name
+        @source = source
         @comments = comments
+        @source = source
       end
 
       # @return [String]
@@ -268,7 +274,7 @@ module Solargraph
       # @deprecated
       # @return [String]
       def identity
-        @identity ||= "#{closure&.path}|#{name}"
+        @identity ||= "#{closure&.path}|#{name}|#{location}"
       end
 
       # @return [String, nil]
@@ -296,7 +302,7 @@ module Solargraph
       def desc
         closure_info = closure&.desc
         binder_info = binder&.desc
-        "[#{type_desc}, closure=#{closure_info}, binder=#{binder}"
+        "[name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}]"
       end
 
       def inspect

data/lib/solargraph/pin/base_variable.rb

@@ -11,12 +11,14 @@ module Solargraph
 
       attr_accessor :mass_assignment
 
+      # @param return_type [ComplexType, nil]
       # @param assignment [Parser::AST::Node, nil]
-      def initialize assignment: nil, **splat
+      def initialize assignment: nil, return_type: nil, **splat
         super(**splat)
         @assignment = assignment
         # @type [nil, ::Array(Parser::AST::Node, Integer)]
         @mass_assignment = nil
+        @return_type = return_type
       end
 
       def completion_item_kind
@@ -32,7 +34,10 @@ module Solargraph
         @return_type ||= generate_complex_type
       end
 
+      # @sg-ignore
       def nil_assignment?
+        # this will always be false - should it be return_type ==
+        #   ComplexType::NIL or somesuch?
         return_type.nil?
       end
 
@@ -88,6 +93,7 @@ module Solargraph
         ComplexType::UNDEFINED
       end
 
+      # @param other [Object]
       def == other
         return false unless super
         assignment == other.assignment

data/lib/solargraph/pin/block.rb

@@ -3,6 +3,8 @@
 module Solargraph
   module Pin
     class Block < Callable
+      include Breakable
+
       # @return [Parser::AST::Node]
       attr_reader :receiver
 

data/lib/solargraph/pin/breakable.rb

@@ -0,0 +1,9 @@
+module Solargraph
+  module Pin
+    # Mix-in for pins which enclose code which the 'break' statement works with-in - e.g., blocks, when, until, ...
+    module Breakable
+      # @return [Parser::AST::Node]
+      attr_reader :node
+    end
+  end
+end

data/lib/solargraph/pin/local_variable.rb

@@ -6,13 +6,19 @@ module Solargraph
       # @return [Range]
       attr_reader :presence
 
+      def presence_certain?
+        @presence_certain
+      end
+
       # @param assignment [AST::Node, nil]
       # @param presence [Range, nil]
+      # @param presence_certain [Boolean]
       # @param splat [Hash]
-      def initialize assignment: nil, presence: nil, **splat
+      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
         super(**splat)
         @assignment = assignment
         @presence = presence
+        @presence_certain = presence_certain
       end
 
       # @param pin [self]

data/lib/solargraph/pin/method.rb

@@ -166,9 +166,9 @@ module Solargraph
       def desc
         # ensure the signatures line up when logged
         if signatures.length > 1
-          "\n#{to_rbs}\n"
+          path + " \n#{to_rbs}\n"
         else
-          to_rbs
+          super
         end
       end
 
@@ -196,13 +196,14 @@ module Solargraph
         name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
       end
 
+      # @sg-ignore
       def documentation
         if @documentation.nil?
-          @documentation ||= super || ''
+          method_docs ||= super || ''
           param_tags = docstring.tags(:param)
           unless param_tags.nil? or param_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Params:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Params:\n"
             lines = []
             param_tags.each do |p|
               l = "* #{p.name}"
@@ -210,12 +211,12 @@ module Solargraph
               l += " #{p.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           yieldparam_tags = docstring.tags(:yieldparam)
           unless yieldparam_tags.nil? or yieldparam_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Block Params:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Block Params:\n"
             lines = []
             yieldparam_tags.each do |p|
               l = "* #{p.name}"
@@ -223,12 +224,12 @@ module Solargraph
               l += " #{p.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           yieldreturn_tags = docstring.tags(:yieldreturn)
           unless yieldreturn_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Block Returns:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Block Returns:\n"
             lines = []
             yieldreturn_tags.each do |r|
               l = "*"
@@ -236,12 +237,12 @@ module Solargraph
               l += " #{r.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           return_tags = docstring.tags(:return)
           unless return_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Returns:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Returns:\n"
             lines = []
             return_tags.each do |r|
               l = "*"
@@ -249,10 +250,11 @@ module Solargraph
               l += " #{r.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
-          @documentation += "\n\n" unless @documentation.empty?
-          @documentation += "Visibility: #{visibility}"
+          method_docs += "\n\n" unless method_docs.empty?
+          method_docs += "Visibility: #{visibility}"
+          @documentation = method_docs
           concat_example_tags
         end
         @documentation.to_s
@@ -315,7 +317,7 @@ module Solargraph
         @anon_splat
       end
 
-      # @param [ApiMap]
+      # @param api_map [ApiMap]
       # @return [self]
       def resolve_ref_tag api_map
         return self if @resolved_ref_tag

data/lib/solargraph/pin/namespace.rb

@@ -14,21 +14,23 @@ module Solargraph
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
       # @param gates [::Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], **splat
+      # @param name [String]
+      def initialize type: :class, visibility: :public, gates: [''], name: '', **splat
         # super(location, namespace, name, comments)
-        super(**splat)
+        super(**splat, name: name)
         @type = type
         @visibility = visibility
         if name.start_with?('::')
-          @name = name[2..-1]
+          # @type [String]
+          name = name[2..-1] || ''
           @closure = Solargraph::Pin::ROOT_PIN
         end
         @open_gates = gates
-        if @name.include?('::')
+        if name.include?('::')
           # In this case, a chained namespace was opened (e.g., Foo::Bar)
           # but Foo does not exist.
-          parts = @name.split('::')
-          @name = parts.pop
+          parts = name.split('::')
+          name = parts.pop
           closure_name = if [Solargraph::Pin::ROOT_PIN, nil].include?(closure)
             ''
           else
@@ -38,6 +40,7 @@ module Solargraph
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
           @context = nil
         end
+        @name = name
       end
 
       def to_rbs
@@ -48,7 +51,7 @@ module Solargraph
         if name.nil? || name.empty?
           '(top-level)'
         else
-          return_type.rooted_tags
+          super
         end
       end