Add 'defined?' keyword

Author: mikeygough

lib/ruby_lsp/listeners/hover.rb

@@ -15,6 +15,7 @@ class Hover
         Prism::ConstantWriteNode,
         Prism::ConstantPathNode,
         Prism::DefNode,
+        Prism::DefinedNode,
         Prism::GlobalVariableAndWriteNode,
         Prism::GlobalVariableOperatorWriteNode,
         Prism::GlobalVariableOrWriteNode,
@@ -66,6 +67,7 @@ def initialize(response_builder, global_state, uri, node_context, dispatcher, so
           :on_constant_path_node_enter,
           :on_call_node_enter,
           :on_def_node_enter,
+          :on_defined_node_enter,
           :on_global_variable_and_write_node_enter,
           :on_global_variable_operator_write_node_enter,
           :on_global_variable_or_write_node_enter,
@@ -125,6 +127,11 @@ def on_def_node_enter(node)
         handle_keyword_documentation(node.def_keyword)
       end
 
+      #: (Prism::DefinedNode node) -> void
+      def on_defined_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       #: (Prism::InterpolatedStringNode node) -> void
       def on_interpolated_string_node_enter(node)
         generate_heredoc_hover(node)

lib/ruby_lsp/static_docs.rb

@@ -18,6 +18,7 @@ module RubyLsp
     "case" => "Starts a case expression for pattern matching or multiple condition checking",
     "class" => "Defines a class and its methods",
     "def" => "Defines a method",
+    "defined?" => "Checks if a constant or method is defined",
     "yield" => "Invokes the passed block with the given arguments",
   }.freeze #: Hash[String, String]
 end

static_docs/defined?.md

@@ -0,0 +1,100 @@
+# Defined?
+
+In Ruby, the `defined?` keyword is a special operator that checks whether a given expression is defined and returns a description of that expression, or `nil` if the expression is not defined.
+
+```ruby
+# Basic defined? usage
+x = 42
+puts defined?(x)      # Output: local-variable
+puts defined?(y)      # Output: nil
+puts defined?(puts)   # Output: method
+```
+
+The `defined?` operator can check various types of expressions and returns different description strings based on the type.
+
+```ruby
+# Checking different types
+class Example
+  CONSTANT = "Hello"
+  @@class_var = "World"
+
+  def check_definitions
+    @instance_var = "!"
+
+    puts defined?(CONSTANT)     # Output: constant
+    puts defined?(@@class_var)  # Output: class variable
+    puts defined?(@instance_var) # Output: instance-variable
+    puts defined?(yield)        # Output: yield (if block given)
+    puts defined?(super)        # Output: super (if method has super)
+  end
+end
+
+example = Example.new
+puts defined?(Example)   # Output: constant
+puts defined?(String)    # Output: constant
+puts defined?("string")  # Output: expression
+```
+
+## Common Use Cases
+
+The `defined?` operator is often used for safe navigation and checking existence before execution.
+
+```ruby
+def safe_operation(value)
+  return "No block given" unless defined?(yield)
+
+  if defined?(value.length)
+    "Length is #{value.length}"
+  else
+    "Cannot determine length"
+  end
+end
+
+puts safe_operation([1, 2, 3]) { |x| x * 2 }  # Output: Length is 3
+puts safe_operation(42) { |x| x * 2 }         # Output: Cannot determine length
+puts safe_operation([1, 2, 3])                # Output: No block given
+```
+
+## Method and Block Checking
+
+`defined?` is particularly useful for checking method existence and block presence.
+
+```ruby
+class SafeCaller
+  def execute
+    if defined?(before_execute)
+      before_execute
+    end
+
+    puts "Executing main logic"
+
+    if defined?(after_execute)
+      after_execute
+    end
+  end
+
+  def after_execute
+    puts "After execution"
+  end
+end
+
+caller = SafeCaller.new
+caller.execute
+# Output:
+# Executing main logic
+# After execution
+
+# Block checking
+def process_with_block
+  if defined?(yield)
+    "Block given: #{yield}"
+  else
+    "No block given"
+  end
+end
+
+puts process_with_block { "Hello!" }  # Output: Block given: Hello!
+puts process_with_block               # Output: No block given
+```
+
+The `defined?` operator is a powerful tool for writing defensive code and handling optional features or dependencies in Ruby programs.