solargraph 0.54.5 → 0.55.4

data/lib/solargraph/parser/flow_sensitive_typing.rb

@@ -0,0 +1,227 @@
+module Solargraph
+  module Parser
+    class FlowSensitiveTyping
+      include Solargraph::Parser::NodeMethods
+
+      # @param locals [Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
+      def initialize(locals, enclosing_breakable_pin = nil)
+        @locals = locals
+        @enclosing_breakable_pin = enclosing_breakable_pin
+      end
+
+      # @param and_node [Parser::AST::Node]
+      def process_and(and_node, true_ranges = [])
+        lhs = and_node.children[0]
+        rhs = and_node.children[1]
+
+        before_rhs_loc = rhs.location.expression.adjust(begin_pos: -1)
+        before_rhs_pos = Position.new(before_rhs_loc.line, before_rhs_loc.column)
+
+        rhs_presence = Range.new(before_rhs_pos,
+                                 get_node_end_position(rhs))
+        process_isa(lhs, true_ranges + [rhs_presence])
+      end
+
+      # @param if_node [Parser::AST::Node]
+      def process_if(if_node)
+        #
+        # See if we can refine a type based on the result of 'if foo.nil?'
+        #
+        # [3] pry(main)> require 'parser/current'; Parser::CurrentRuby.parse("if foo.is_a? Baz; then foo; else bar; end")
+        # => s(:if,
+        #   s(:send,
+        #     s(:send, nil, :foo), :is_a?,
+        #     s(:const, nil, :Baz)),
+        #   s(:send, nil, :foo),
+        #   s(:send, nil, :bar))
+        # [4] pry(main)>
+        conditional_node = if_node.children[0]
+        then_clause = if_node.children[1]
+        else_clause = if_node.children[2]
+
+        true_ranges = []
+        if always_breaks?(else_clause)
+          unless enclosing_breakable_pin.nil?
+            rest_of_breakable_body = Range.new(get_node_end_position(if_node),
+                                               get_node_end_position(enclosing_breakable_pin.node))
+            true_ranges << rest_of_breakable_body
+          end
+        end
+
+        unless then_clause.nil?
+          #
+          # Add specialized locals for the then clause range
+          #
+          before_then_clause_loc = then_clause.location.expression.adjust(begin_pos: -1)
+          before_then_clause_pos = Position.new(before_then_clause_loc.line, before_then_clause_loc.column)
+          true_ranges << Range.new(before_then_clause_pos,
+                                   get_node_end_position(then_clause))
+        end
+
+        process_conditional(conditional_node, true_ranges)
+      end
+
+      class << self
+        include Logging
+      end
+
+      # Find a variable pin by name and where it is used.
+      #
+      # Resolves our most specific view of this variable's type by
+      # preferring pins created by flow-sensitive typing when we have
+      # them based on the Closure and Location.
+      #
+      # @param pins [Array<Pin::LocalVariable>]
+      # @param closure [Pin::Closure]
+      # @param location [Location]
+      def self.visible_pins(pins, name, closure, location)
+        logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location})" }
+        pins_with_name = pins.select { |p| p.name == name }
+        if pins_with_name.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => [] - no pins with name" }
+          return []
+        end
+        pins_with_specific_visibility = pins.select { |p| p.name == name && p.presence && p.visible_at?(closure, location) }
+        if pins_with_specific_visibility.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{pins_with_name} - no pins with specific visibility" }
+          return pins_with_name
+        end
+        visible_pins_specific_to_this_closure = pins_with_specific_visibility.select { |p| p.closure == closure }
+        if visible_pins_specific_to_this_closure.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{pins_with_specific_visibility} - no visible pins specific to this closure (#{closure})}" }
+          return pins_with_specific_visibility
+        end
+        flow_defined_pins = pins_with_specific_visibility.select { |p| p.presence_certain? }
+        if flow_defined_pins.empty?
+          logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{visible_pins_specific_to_this_closure} - no flow-defined pins" }
+          return visible_pins_specific_to_this_closure
+        end
+
+        logger.debug { "FlowSensitiveTyping#visible_pins(name=#{name}, closure=#{closure}, location=#{location}) => #{flow_defined_pins}" }
+
+        flow_defined_pins
+      end
+
+      include Logging
+
+      private
+
+      # @param pin [Pin::LocalVariable]
+      # @param if_node [Parser::AST::Node]
+      def add_downcast_local(pin, downcast_type_name, presence)
+        # @todo Create pin#update method
+        new_pin = Solargraph::Pin::LocalVariable.new(
+          location: pin.location,
+          closure: pin.closure,
+          name: pin.name,
+          assignment: pin.assignment,
+          comments: pin.comments,
+          presence: presence,
+          return_type: ComplexType.try_parse(downcast_type_name),
+          presence_certain: true,
+          source: :flow_sensitive_typing
+        )
+        locals.push(new_pin)
+      end
+
+      # @param facts_by_pin [Hash{Pin::LocalVariable => Array<Hash{Symbol => String}>}]
+      # @param presences [Array<Range>]
+      # @return [void]
+      def process_facts(facts_by_pin, presences)
+        #
+        # Add specialized locals for the rest of the block
+        #
+        facts_by_pin.each_pair do |pin, facts|
+          facts.each do |fact|
+            downcast_type_name = fact.fetch(:type)
+            presences.each do |presence|
+              add_downcast_local(pin, downcast_type_name, presence)
+            end
+          end
+        end
+      end
+
+      # @param conditional_node [Parser::AST::Node]
+      def process_conditional(conditional_node, true_ranges)
+        if conditional_node.type == :send
+          process_isa(conditional_node, true_ranges)
+        elsif conditional_node.type == :and
+          process_and(conditional_node, true_ranges)
+        end
+      end
+
+      # @param isa_node [Parser::AST::Node]
+      # @return [Array(String, String)]
+      def parse_isa(isa_node)
+        return unless isa_node&.type == :send && isa_node.children[1] == :is_a?
+        # Check if conditional node follows this pattern:
+        #   s(:send,
+        #     s(:send, nil, :foo), :is_a?,
+        #     s(:const, nil, :Baz)),
+        isa_receiver = isa_node.children[0]
+        isa_type_name = type_name(isa_node.children[2])
+        return unless isa_type_name
+
+        # check if isa_receiver looks like this:
+        #  s(:send, nil, :foo)
+        # and set variable_name to :foo
+        if isa_receiver&.type == :send && isa_receiver.children[0].nil? && isa_receiver.children[1].is_a?(Symbol)
+          variable_name = isa_receiver.children[1].to_s
+        end
+        # or like this:
+        # (lvar :repr)
+        variable_name = isa_receiver.children[0].to_s if isa_receiver&.type == :lvar
+        return unless variable_name
+
+        [isa_type_name, variable_name]
+      end
+
+      def find_local(variable_name, position)
+        pins = locals.select { |pin| pin.name == variable_name && pin.presence.include?(position) }
+        return unless pins.length == 1
+        pins.first
+      end
+
+      def process_isa(isa_node, true_presences)
+        isa_type_name, variable_name = parse_isa(isa_node)
+        return if variable_name.nil? || variable_name.empty?
+        isa_position = Range.from_node(isa_node).start
+
+        pin = find_local(variable_name, isa_position)
+        return unless pin
+
+        if_true = {}
+        if_true[pin] ||= []
+        if_true[pin] << { type: isa_type_name }
+        process_facts(if_true, true_presences)
+      end
+
+      # @param node [Parser::AST::Node]
+      def type_name(node)
+        # e.g.,
+        #  s(:const, nil, :Baz)
+        return unless node.type == :const
+        module_node = node.children[0]
+        class_node = node.children[1]
+
+        return class_node.to_s if module_node.nil?
+
+        module_type_name = type_name(module_node)
+        return unless module_type_name
+
+        "#{module_type_name}::#{class_node}"
+      end
+
+      # @todo "return type could not be inferred" should not trigger here
+      # @sg-ignore
+      # @param clause_node [Parser::AST::Node]
+      def always_breaks?(clause_node)
+        clause_node&.type == :break
+      end
+
+      attr_reader :locals
+
+      attr_reader :enclosing_breakable_pin
+    end
+  end
+end

data/lib/solargraph/parser/node_methods.rb

@@ -78,6 +78,20 @@ module Solargraph
       def convert_hash node
         raise NotImplementedError
       end
+
+      # @abstract
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_start_position(node)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_end_position(node)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/solargraph/parser/node_processor.rb

@@ -9,7 +9,7 @@ module Solargraph
       autoload :Base, 'solargraph/parser/node_processor/base'
 
       class << self
-        # @type [Hash<Symbol, Class<NodeProcessor::Base>>]
+        # @type [Hash{Symbol => Class<NodeProcessor::Base>}]
         @@processors ||= {}
 
         # Register a processor for a node type.
@@ -31,7 +31,8 @@ module Solargraph
         if pins.empty?
           pins.push Pin::Namespace.new(
             location: region.source.location,
-            name: ''
+            name: '',
+            source: :parser,
           )
         end
         return [pins, locals] unless Parser.is_ast_node?(node)

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

@@ -3,6 +3,15 @@
 require 'parser/current'
 require 'parser/source/buffer'
 
+# Awaiting ability to use a version containing https://github.com/whitequark/parser/pull/1076
+#
+# @!parse
+#   class ::Parser::Base < ::Parser::Builder
+#     # @return [Integer]
+#     def version; end
+#   end
+#   class ::Parser::CurrentRuby < ::Parser::Base; end
+
 module Solargraph
   module Parser
     module ParserGem

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

@@ -12,7 +12,7 @@ require 'ast'
 #     class Node
 #       # New children
 #
-#       # @return [Array<self>]
+#       # @return [Array<self, Integer, String, Symbol, nil>]
 #       attr_reader :children
 #     end
 #   end
@@ -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/alias_node.rb

@@ -12,7 +12,8 @@ module Solargraph
               closure: region.closure,
               name: node.children[0].children[0].to_s,
               original: node.children[1].children[0].to_s,
-              scope: region.scope || :instance
+              scope: region.scope || :instance,
+              source: :parser
             )
             process_children
           end

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

@@ -21,7 +21,8 @@ module Solargraph
                                 assignment: u.children[1],
                                 asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
                                 presence: callable.location.range,
-                                decl: get_decl(u)
+                                decl: get_decl(u),
+                                source: :parser
                               )
                   callable.parameters.push locals.last
                 end
@@ -40,7 +41,8 @@ module Solargraph
               location: loc,
               closure: callable,
               presence: region.closure.location.range,
-              decl: get_decl(node)
+              decl: get_decl(node),
+              source: :parser
             )
             callable.parameters.push locals.last
           end

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

@@ -13,7 +13,8 @@ module Solargraph
               Solargraph::Pin::Namespace.new(
                 location: location,
                 type: :class,
-                name: unpack_name(node.children[0].children[0])
+                name: unpack_name(node.children[0].children[0]),
+                source: :parser,
               )
             else
               region.closure
@@ -24,7 +25,8 @@ module Solargraph
               node: node,
               receiver: node.children[0],
               comments: comments_for(node),
-              scope: region.scope || region.closure.context.scope
+              scope: region.scope || region.closure.context.scope,
+              source: :parser
             )
             process_children region.update(closure: pins.last)
           end

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

@@ -8,17 +8,38 @@ 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,
               name: const_name,
               comments: comments_for(node),
-              assignment: node.children[2]
+              assignment: node.children[2],
+              source: :parser
             )
             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/cvasgn_node.rb

@@ -12,7 +12,8 @@ module Solargraph
               closure: region.closure,
               name: node.children[0].to_s,
               comments: comments_for(node),
-              assignment: node.children[1]
+              assignment: node.children[1],
+              source: :parser
             )
             process_children
           end

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

@@ -15,7 +15,8 @@ module Solargraph
               comments: comments_for(node),
               scope: scope,
               visibility: scope == :instance && name == 'initialize' ? :private : region.visibility,
-              node: node
+              node: node,
+              source: :parser,
             )
             if region.visibility == :module_function
               pins.push Solargraph::Pin::Method.new(
@@ -26,7 +27,8 @@ module Solargraph
                 scope: :class,
                 visibility: :public,
                 parameters: methpin.parameters,
-                node: methpin.node
+                node: methpin.node,
+                source: :parser,
               )
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
@@ -36,7 +38,8 @@ module Solargraph
                 scope: :instance,
                 visibility: :private,
                 parameters: methpin.parameters,
-                node: methpin.node
+                node: methpin.node,
+                source: :parser,
               )
             else
               pins.push methpin

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

@@ -25,7 +25,8 @@ module Solargraph
               comments: comments_for(node),
               scope: :class,
               visibility: s_visi,
-              node: node
+              node: node,
+              source: :parser,
             )
             process_children region.update(closure: pins.last, scope: :class)
           end

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

@@ -12,7 +12,8 @@ module Solargraph
               closure: region.closure,
               name: node.children[0].to_s,
               comments: comments_for(node),
-              assignment: node.children[1]
+              assignment: node.children[1],
+              source: :parser
             )
             process_children
           end

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

@@ -14,7 +14,8 @@ module Solargraph
               closure: region.closure,
               name: node.children[0].to_s,
               comments: comments_for(node),
-              assignment: node.children[1]
+              assignment: node.children[1],
+              source: :parser
             )
             if region.visibility == :module_function
               here = get_node_start_position(node)
@@ -25,7 +26,8 @@ module Solargraph
                   closure: Pin::Namespace.new(type: :module, closure: region.closure.closure, name: region.closure.name),
                   name: node.children[0].to_s,
                   comments: comments_for(node),
-                  assignment: node.children[1]
+                  assignment: node.children[1],
+                  source: :parser
                 )
               end
             end

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

@@ -17,7 +17,8 @@ module Solargraph
               name: node.children[0].to_s,
               assignment: node.children[1],
               comments: comments_for(node),
-              presence: presence
+              presence: presence,
+              source: :parser
             )
             process_children
           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,
@@ -20,18 +30,31 @@ module Solargraph
               name: unpack_name(node.children[0]),
               comments: comments_for(node),
               visibility: :public,
-              gates: region.closure.gates.freeze
+              gates: region.closure.gates.freeze,
+              source: :parser
             )
             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,
+                source: :parser
               )
             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