solargraph 0.58.0 → 0.59.0.dev.1

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

@@ -1,22 +1,22 @@
-# 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)
-            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-            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
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class AndNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            process_children
+
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_and(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,59 +1,61 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class ArgsNode < Parser::NodeProcessor::Base
-          def process
-            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),
-                                source: :parser
-                              )
-                  callable.parameters.push locals.last
-                end
-              end
-            end
-            process_children
-          end
-
-          private
-
-          # @param callable [Pin::Callable]
-          # @return [void]
-          def forward(callable)
-            loc = get_node_location(node)
-            locals.push Solargraph::Pin::Parameter.new(
-              location: loc,
-              closure: callable,
-              presence: region.closure.location.range,
-              decl: get_decl(node),
-              source: :parser
-            )
-            callable.parameters.push locals.last
-          end
-
-          # @param node [AST::Node]
-          # @return [Symbol]
-          def get_decl node
-            node.type
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class ArgsNode < Parser::NodeProcessor::Base
+          def process
+            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,
+                                # @sg-ignore Need to add nil check here
+                                presence: callable.location.range,
+                                decl: get_decl(u),
+                                source: :parser
+                              )
+                  callable.parameters.push locals.last
+                end
+              end
+            end
+            process_children
+          end
+
+          private
+
+          # @param callable [Pin::Callable]
+          # @return [void]
+          def forward(callable)
+            loc = get_node_location(node)
+            locals.push Solargraph::Pin::Parameter.new(
+              location: loc,
+              closure: callable,
+              # @sg-ignore Need to add nil check here
+              presence: region.closure.location.range,
+              decl: get_decl(node),
+              source: :parser
+            )
+            callable.parameters.push locals.last
+          end
+
+          # @param node [AST::Node]
+          # @return [Symbol]
+          def get_decl node
+            node.type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,24 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class BeginNode < Parser::NodeProcessor::Base
-          def process
-            process_children
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class BeginNode < Parser::NodeProcessor::Base
+          def process
+            # We intentionally don't create a CompoundStatement pin
+            # here, as this is not necessarily a control flow block -
+            # e.g., a begin...end without rescue or ensure should be
+            # treated by flow sensitive typing as if the begin and end
+            # didn't exist at all.  As such, we create the
+            # CompoundStatement pins around the things which actually
+            # result in control flow changes - like
+            # if/while/rescue/etc
+
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,46 +1,46 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class BlockNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            location = get_node_location(node)
-            parent = if other_class_eval?
-              Solargraph::Pin::Namespace.new(
-                location: location,
-                type: :class,
-                name: unpack_name(node.children[0].children[0]),
-                source: :parser,
-              )
-            else
-              region.closure
-            end
-            block_pin = Solargraph::Pin::Block.new(
-              location: location,
-              closure: parent,
-              node: node,
-              receiver: node.children[0],
-              comments: comments_for(node),
-              scope: region.scope || region.closure.context.scope,
-              source: :parser
-            )
-            pins.push block_pin
-            process_children region.update(closure: block_pin)
-          end
-
-          private
-
-          def other_class_eval?
-            node.children[0].type == :send &&
-              node.children[0].children[1] == :class_eval &&
-              [:cbase, :const].include?(node.children[0].children[0]&.type)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class BlockNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            location = get_node_location(node)
+            scope = region.scope || region.closure.context.scope
+            if other_class_eval?
+              clazz_name = unpack_name(node.children[0].children[0])
+              # instance variables should come from the Class<T> type
+              # - i.e., treated as class instance variables
+              context = ComplexType.try_parse("Class<#{clazz_name}>")
+              scope = :class
+            end
+            block_pin = Solargraph::Pin::Block.new(
+              location: location,
+              closure: region.closure,
+              node: node,
+              context: context,
+              receiver: node.children[0],
+              comments: comments_for(node),
+              scope: scope,
+              source: :parser
+            )
+            pins.push block_pin
+            process_children region.update(closure: block_pin)
+          end
+
+          private
+
+          def other_class_eval?
+            node.children[0].type == :send &&
+              node.children[0].children[1] == :class_eval &&
+              # @sg-ignore Need to add nil check here
+              [:cbase, :const].include?(node.children[0].children[0]&.type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,53 +1,60 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class DefNode < Parser::NodeProcessor::Base
-          def process
-            name = node.children[0].to_s
-            scope = region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance)
-            methpin = Solargraph::Pin::Method.new(
-              location: get_node_location(node),
-              closure: region.closure,
-              name: name,
-              comments: comments_for(node),
-              scope: scope,
-              visibility: scope == :instance && name == 'initialize' ? :private : region.visibility,
-              node: node,
-              source: :parser,
-            )
-            if region.visibility == :module_function
-              pins.push Solargraph::Pin::Method.new(
-                location: methpin.location,
-                closure: methpin.closure,
-                name: methpin.name,
-                comments: methpin.comments,
-                scope: :class,
-                visibility: :public,
-                parameters: methpin.parameters,
-                node: methpin.node,
-                source: :parser,
-              )
-              pins.push Solargraph::Pin::Method.new(
-                location: methpin.location,
-                closure: methpin.closure,
-                name: methpin.name,
-                comments: methpin.comments,
-                scope: :instance,
-                visibility: :private,
-                parameters: methpin.parameters,
-                node: methpin.node,
-                source: :parser,
-              )
-            else
-              pins.push methpin
-            end
-            process_children region.update(closure: methpin, scope: methpin.scope)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class DefNode < Parser::NodeProcessor::Base
+          def process
+            name = node.children[0].to_s
+            scope = region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance)
+            # specify context explicitly instead of relying on
+            # closure, as they may differ (e.g., defs inside
+            # class_eval)
+            method_context = scope == :instance ? region.closure.binder.namespace_type : region.closure.binder
+            methpin = Solargraph::Pin::Method.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: name,
+              context: method_context,
+              comments: comments_for(node),
+              scope: scope,
+              visibility: scope == :instance && name == 'initialize' ? :private : region.visibility,
+              node: node,
+              source: :parser,
+            )
+            if region.visibility == :module_function
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: methpin.name,
+                context: method_context,
+                comments: methpin.comments,
+                scope: :class,
+                visibility: :public,
+                parameters: methpin.parameters,
+                node: methpin.node,
+                source: :parser,
+              )
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: methpin.name,
+                context: method_context,
+                comments: methpin.comments,
+                scope: :instance,
+                visibility: :private,
+                parameters: methpin.parameters,
+                node: methpin.node,
+                source: :parser,
+              )
+            else
+              pins.push methpin
+            end
+            process_children region.update(closure: methpin, scope: methpin.scope)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,23 +1,53 @@
-# 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)
-            # @sg-ignore
-            # @type [Solargraph::Pin::Breakable, nil]
-            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
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class IfNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            FlowSensitiveTyping.new(locals,
+                                    ivars,
+                                    enclosing_breakable_pin,
+                                    enclosing_compound_statement_pin).process_if(node)
+            condition_node = node.children[0]
+            if condition_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(condition_node),
+                closure: region.closure,
+                node: condition_node,
+                source: :parser,
+              )
+              NodeProcessor.process(condition_node, region, pins, locals, ivars)
+            end
+            then_node = node.children[1]
+            if then_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(then_node),
+                closure: region.closure,
+                node: then_node,
+                source: :parser,
+              )
+              NodeProcessor.process(then_node, region, pins, locals, ivars)
+            end
+
+            else_node = node.children[2]
+            if else_node
+              pins.push Solargraph::Pin::CompoundStatement.new(
+                location: get_node_location(else_node),
+                closure: region.closure,
+                node: else_node,
+                source: :parser,
+              )
+              NodeProcessor.process(else_node, region, pins, locals, ivars)
+            end
+
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,40 +1,41 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class IvasgnNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            loc = get_node_location(node)
-            pins.push Solargraph::Pin::InstanceVariable.new(
-              location: loc,
-              closure: region.closure,
-              name: node.children[0].to_s,
-              comments: comments_for(node),
-              assignment: node.children[1],
-              source: :parser
-            )
-            if region.visibility == :module_function
-              here = get_node_start_position(node)
-              named_path = named_path_pin(here)
-              if named_path.is_a?(Pin::Method)
-                pins.push Solargraph::Pin::InstanceVariable.new(
-                  location: loc,
-                  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],
-                  source: :parser
-                )
-              end
-            end
-            process_children
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class IvasgnNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            loc = get_node_location(node)
+            ivars.push Solargraph::Pin::InstanceVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1],
+              source: :parser
+            )
+            if region.visibility == :module_function
+              here = get_node_start_position(node)
+              # @type [Pin::Closure, nil]
+              named_path = named_path_pin(here)
+              if named_path.is_a?(Pin::Method)
+                ivars.push Solargraph::Pin::InstanceVariable.new(
+                  location: loc,
+                  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],
+                  source: :parser
+                )
+              end
+            end
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,29 +1,30 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class LvasgnNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            here = get_node_start_position(node)
-            presence = Range.new(here, region.closure.location.range.ending)
-            loc = get_node_location(node)
-            locals.push Solargraph::Pin::LocalVariable.new(
-              location: loc,
-              closure: region.closure,
-              name: node.children[0].to_s,
-              assignment: node.children[1],
-              comments: comments_for(node),
-              presence: presence,
-              source: :parser
-            )
-            process_children
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class LvasgnNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            here = get_node_start_position(node)
+            # @sg-ignore Need to add nil check here
+            presence = Range.new(here, region.closure.location.range.ending)
+            loc = get_node_location(node)
+            locals.push Solargraph::Pin::LocalVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              assignment: node.children[1],
+              comments: comments_for(node),
+              presence: presence,
+              source: :parser
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end