solargraph 0.54.0 → 0.55.0

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

@@ -6,22 +6,25 @@ module Solargraph
       module NodeProcessors
         class ArgsNode < Parser::NodeProcessor::Base
           def process
-            if node.type == :forward_args
-              forward
-            else
-              node.children.each do |u|
-                loc = get_node_location(u)
-                locals.push Solargraph::Pin::Parameter.new(
-                  location: loc,
-                  closure: region.closure,
-                  comments: comments_for(node),
-                  name: u.children[0].to_s,
-                  assignment: u.children[1],
-                  asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
-                  presence: region.closure.location.range,
-                  decl: get_decl(u)
-                )
-                region.closure.parameters.push locals.last
+            callable = region.closure
+            if callable.is_a? Pin::Callable
+              if node.type == :forward_args
+                forward(callable)
+              else
+                node.children.each do |u|
+                  loc = get_node_location(u)
+                  locals.push Solargraph::Pin::Parameter.new(
+                                location: loc,
+                                closure: callable,
+                                comments: comments_for(node),
+                                name: u.children[0].to_s,
+                                assignment: u.children[1],
+                                asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
+                                presence: callable.location.range,
+                                decl: get_decl(u)
+                              )
+                  callable.parameters.push locals.last
+                end
               end
             end
             process_children
@@ -29,16 +32,17 @@ module Solargraph
 
           private
 
+          # @param callable [Pin::Callable]
           # @return [void]
-          def forward
+          def forward(callable)
             loc = get_node_location(node)
             locals.push Solargraph::Pin::Parameter.new(
               location: loc,
-              closure: region.closure,
+              closure: callable,
               presence: region.closure.location.range,
               decl: get_decl(node)
             )
-            region.closure.parameters.push locals.last
+            callable.parameters.push locals.last
           end
 
           # @param node [AST::Node]

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

@@ -30,11 +30,17 @@ module Solargraph
 
             lhs_arr.each_with_index do |lhs, i|
               location = get_node_location(lhs)
+              pin = if lhs.type == :lvasgn
+                      # lvasgn is a local variable
+                      locals.find { |l| l.location == location }
+                    else
+                      # e.g., ivasgn is an instance variable, etc
+                      pins.find { |iv| iv.location == location && iv.is_a?(Pin::BaseVariable) }
+                    end
               # @todo in line below, nothing in typechecking alerts
               #   when a non-existant method is called on 'l'
-              pin = locals.find { |l| l.location == location }
               if pin.nil?
-                Solargraph.logger.debug "Could not find pin in location #{location}"
+                Solargraph.logger.debug { "Could not find local for masgn= value in location #{location.inspect} in #{lhs_arr} - masgn = #{masgn}, lhs.type = #{lhs.type}" }
                 next
               end
               pin.mass_assignment = [mass_rhs, i]

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

@@ -92,7 +92,7 @@ module Solargraph
                 pins.push method_pin
                 method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
                 if method_pin.return_type.defined?
-                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.items.map(&:rooted_tags), 'value')
                 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,20 +4,18 @@ 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
     end
 
-    def self.rubyvm?
-      false
-    end
-
     # @deprecated
     Legacy = ParserGem
 
     ClassMethods = ParserGem::ClassMethods
-
+    # @todo should be able to just 'extend ClassMethods' here and
+    #   typecheck things off it in strict mode
     extend ParserGem::ClassMethods
 
     NodeMethods = ParserGem::NodeMethods

data/lib/solargraph/pin/base.rb

@@ -15,6 +15,9 @@ module Solargraph
       # @return [Solargraph::Location]
       attr_reader :location
 
+      # @return [Solargraph::Location]
+      attr_reader :type_location
+
       # @return [String]
       attr_reader :name
 
@@ -24,15 +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, 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]
@@ -66,11 +77,14 @@ module Solargraph
       # @param context_type [ComplexType] The receiver type
       # @return [self]
       def resolve_generics definitions, context_type
-        transformed = transform_types { |t| t.resolve_generics(definitions, context_type) if t }
-        transformed.erase_generics(definitions.generics)
+        transform_types { |t| t.resolve_generics(definitions, context_type) if t }
+      end
+
+      def all_rooted?
+        !return_type || return_type.all_rooted?
       end
 
-      # @param generics_to_erase [Enumerable<String>]
+      # @param generics_to_erase [::Array<String>]
       # @return [self]
       def erase_generics(generics_to_erase)
         return self if generics_to_erase.empty?
@@ -94,7 +108,7 @@ module Solargraph
       end
 
       def to_s
-        to_rbs
+        desc
       end
 
       # @return [Boolean]
@@ -102,12 +116,9 @@ module Solargraph
         false
       end
 
-      # Pin equality is determined using the #nearly? method and also
-      # requiring both pins to have the same location.
-      #
-      def == other
-        return false unless nearly? other
-        comments == other.comments and location == other.location
+      # @return [Location, nil]
+      def best_location
+        location || type_location
       end
 
       # True if the specified pin is a near match to this one. A near match
@@ -126,6 +137,14 @@ module Solargraph
           )
       end
 
+      # Pin equality is determined using the #nearly? method and also
+      # requiring both pins to have the same location.
+      #
+      def == other
+        return false unless nearly? other
+        comments == other.comments && location == other.location
+      end
+
       # The pin's return type.
       #
       # @return [ComplexType]
@@ -252,9 +271,10 @@ module Solargraph
         result
       end
 
+      # @deprecated
       # @return [String]
       def identity
-        @identity ||= "#{closure.path}|#{name}"
+        @identity ||= "#{closure&.path}|#{name}|#{location}"
       end
 
       # @return [String, nil]
@@ -262,19 +282,29 @@ module Solargraph
         return_type.to_rbs
       end
 
-      # @return [String, nil]
-      def desc
+      # @return [String]
+      def type_desc
+        rbs = to_rbs
+        # RBS doesn't have a way to represent a Class<x> type
+        rbs = return_type.rooted_tags if return_type.name == 'Class'
         if path
-          if to_rbs
-            path + ' ' + to_rbs
+          if rbs
+            path + ' ' + rbs
           else
             path
           end
         else
-          to_rbs
+          rbs
         end
       end
 
+      # @return [String]
+      def desc
+        closure_info = closure&.desc
+        binder_info = binder&.desc
+        "[name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}]"
+      end
+
       def inspect
         "#<#{self.class} `#{self.desc}` at #{self.location.inspect}>"
       end

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
 
@@ -57,7 +62,7 @@ module Solargraph
             # Use the return node for inference. The clip might infer from the
             # first node in a method call instead of the entire call.
             chain = Parser.chain(node, nil, nil)
-            result = chain.infer(api_map, closure, clip.locals).self_to(closure.context.tag)
+            result = chain.infer(api_map, closure, clip.locals).self_to_type(closure.context)
             types.push result unless result.undefined?
           end
         end
@@ -88,11 +93,13 @@ module Solargraph
         ComplexType::UNDEFINED
       end
 
+      # @param other [Object]
       def == other
         return false unless super
         assignment == other.assignment
       end
 
+      # @param pin [self]
       def try_merge! pin
         return false unless super
         @assignment = pin.assignment
@@ -100,8 +107,8 @@ module Solargraph
         true
       end
 
-      def desc
-        "#{to_rbs} = #{assignment&.type.inspect}"
+      def type_desc
+        "#{super} = #{assignment&.type.inspect}"
       end
 
       private