ruby-lsp 0.4.1 → 0.4.3

data/lib/ruby_lsp/requests/code_actions.rb

@@ -21,16 +21,15 @@ module RubyLsp
 
       sig do
         params(
-          uri: String,
           document: Document,
           range: Document::RangeShape,
           context: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(uri, document, range, context)
+      def initialize(document, range, context)
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
         @range = range
         @context = context
       end
@@ -49,7 +48,9 @@ module RubyLsp
           code_action if diagnostic.dig(:data, :correctable) && cover?(range)
         end
 
-        code_actions << refactor_code_action(@range, @uri)
+        # Only add refactor actions if there's a non empty selection in the editor
+        code_actions << refactor_code_action(@range, @uri) unless @range.dig(:start) == @range.dig(:end)
+        code_actions
       end
 
       private

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -21,11 +21,11 @@ module RubyLsp
     class Diagnostics < BaseRequest
       extend T::Sig
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(document: Document).void }
+      def initialize(document)
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
@@ -34,7 +34,7 @@ module RubyLsp
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
         # Don't try to run RuboCop diagnostics for files outside the current working directory
-        return unless @uri.sub("file://", "").start_with?(Dir.pwd)
+        return unless @uri.start_with?(WORKSPACE_URI)
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -29,14 +29,14 @@ module RubyLsp
       def initialize(document, position)
         super(document)
 
-        @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
+        @highlights = T.let([], T::Array[Interface::DocumentHighlight])
         return unless document.parsed?
 
         position = document.create_scanner.find_char_position(position)
         @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentHighlight], Object)) }
       def run
         # no @target means the target is not highlightable
         visit(@document.tree) if @document.parsed? && @target
@@ -90,7 +90,7 @@ module RubyLsp
       sig { params(match: Support::HighlightTarget::HighlightMatch).void }
       def add_highlight(match)
         range = range_from_syntax_tree_node(match.node)
-        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: match.type)
+        @highlights << Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

data/lib/ruby_lsp/requests/document_link.rb

@@ -69,18 +69,18 @@ module RubyLsp
         end
       end
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(document: Document).void }
+      def initialize(document)
         super(document)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI
-        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(uri)
+        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(document.uri)
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
-        @links = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentLink])
+        @links = T.let([], T::Array[Interface::DocumentLink])
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentLink], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentLink], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @links
@@ -91,12 +91,12 @@ module RubyLsp
         match = node.value.match(%r{source://.*#\d+$})
         return unless match
 
-        uri = T.cast(URI(match[0]), URI::Source)
+        uri = T.cast(URI(T.must(match[0])), URI::Source)
         gem_version = T.must(resolve_version(uri))
         file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
         return if file_path.nil?
 
-        @links << LanguageServer::Protocol::Interface::DocumentLink.new(
+        @links << Interface::DocumentLink.new(
           range: range_from_syntax_tree_node(node),
           target: "file://#{file_path}##{uri.line_number}",
           tooltip: "Jump to #{file_path}##{uri.line_number}",

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -66,12 +66,12 @@ module RubyLsp
       class SymbolHierarchyRoot
         extend T::Sig
 
-        sig { returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
+        sig { returns(T::Array[Interface::DocumentSymbol]) }
         attr_reader :children
 
         sig { void }
         def initialize
-          @children = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentSymbol])
+          @children = T.let([], T::Array[Interface::DocumentSymbol])
         end
       end
 
@@ -82,11 +82,11 @@ module RubyLsp
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
         @stack = T.let(
           [@root],
-          T::Array[T.any(SymbolHierarchyRoot, LanguageServer::Protocol::Interface::DocumentSymbol)],
+          T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
         )
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentSymbol], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @root.children
@@ -108,7 +108,7 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Command).void }
       def visit_command(node)
-        return unless ATTR_ACCESSORS.include?(node.message.value)
+        return visit(node.arguments) unless ATTR_ACCESSORS.include?(node.message.value)
 
         node.arguments.parts.each do |argument|
           next unless argument.is_a?(SyntaxTree::SymbolLiteral)
@@ -134,7 +134,9 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::DefNode).void }
       def visit_def(node)
-        if node.target&.value&.value == "self"
+        target = node.target
+
+        if target.is_a?(SyntaxTree::VarRef) && target.value.is_a?(SyntaxTree::Kw) && target.value.value == "self"
           name = "self.#{node.name.value}"
           kind = :method
         else
@@ -180,7 +182,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
-        kind = case node.value
+        value = node.value
+        kind = case value
         when SyntaxTree::Const
           :constant
         when SyntaxTree::CVar, SyntaxTree::IVar
@@ -190,10 +193,10 @@ module RubyLsp
         end
 
         create_document_symbol(
-          name: node.value.value,
+          name: value.value,
           kind: kind,
           range_node: node,
-          selection_range_node: node.value,
+          selection_range_node: value,
         )
       end
 
@@ -205,10 +208,10 @@ module RubyLsp
           kind: Symbol,
           range_node: SyntaxTree::Node,
           selection_range_node: SyntaxTree::Node,
-        ).returns(LanguageServer::Protocol::Interface::DocumentSymbol)
+        ).returns(Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
-        symbol = LanguageServer::Protocol::Interface::DocumentSymbol.new(
+        symbol = Interface::DocumentSymbol.new(
           name: name,
           kind: SYMBOL_KIND[kind],
           range: range_from_syntax_tree_node(range_node),

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -24,7 +24,6 @@ module RubyLsp
           SyntaxTree::BlockNode,
           SyntaxTree::Case,
           SyntaxTree::ClassDeclaration,
-          SyntaxTree::Command,
           SyntaxTree::For,
           SyntaxTree::HashLiteral,
           SyntaxTree::Heredoc,
@@ -64,11 +63,11 @@ module RubyLsp
       def initialize(document)
         super
 
-        @ranges = T.let([], T::Array[LanguageServer::Protocol::Interface::FoldingRange])
+        @ranges = T.let([], T::Array[Interface::FoldingRange])
         @partial_range = T.let(nil, T.nilable(PartialRange))
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
       def run
         if @document.parsed?
           visit(@document.tree)
@@ -100,6 +99,11 @@ module RubyLsp
             add_call_range(node)
             return
           end
+        when SyntaxTree::Command
+          unless same_lines_for_command_and_block?(node)
+            location = node.location
+            add_lines_range(location.start_line, location.end_line - 1)
+          end
         when SyntaxTree::DefNode
           add_def_range(node)
         when SyntaxTree::StringConcat
@@ -110,6 +114,17 @@ module RubyLsp
         super
       end
 
+      # This is to prevent duplicate ranges
+      sig { params(node: T.any(SyntaxTree::Command, SyntaxTree::CommandCall)).returns(T::Boolean) }
+      def same_lines_for_command_and_block?(node)
+        node_block = node.block
+        return false unless node_block
+
+        location = node.location
+        block_location = node_block.location
+        block_location.start_line == location.start_line && block_location.end_line == location.end_line
+      end
+
       class PartialRange
         extend T::Sig
 
@@ -146,9 +161,9 @@ module RubyLsp
           node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
         end
 
-        sig { returns(LanguageServer::Protocol::Interface::FoldingRange) }
+        sig { returns(Interface::FoldingRange) }
         def to_range
-          LanguageServer::Protocol::Interface::FoldingRange.new(
+          Interface::FoldingRange.new(
             start_line: @start_line,
             end_line: @end_line,
             kind: @kind,
@@ -205,7 +220,8 @@ module RubyLsp
 
       sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
-        receiver = T.let(node.receiver, SyntaxTree::Node)
+        receiver = T.let(node.receiver, T.nilable(SyntaxTree::Node))
+
         loop do
           case receiver
           when SyntaxTree::CallNode
@@ -223,18 +239,27 @@ module RubyLsp
           end
         end
 
-        add_lines_range(receiver.location.start_line, node.location.end_line - 1) if receiver
+        if receiver
+          unless node.is_a?(SyntaxTree::CommandCall) && same_lines_for_command_and_block?(node)
+            add_lines_range(
+              receiver.location.start_line,
+              node.location.end_line - 1,
+            )
+          end
+        end
 
         visit(node.arguments)
+        visit(node.block) if node.is_a?(SyntaxTree::CommandCall)
       end
 
       sig { params(node: SyntaxTree::DefNode).void }
       def add_def_range(node)
         # For an endless method with no arguments, `node.params` returns `nil` for Ruby 3.0, but a `Syntax::Params`
         # for Ruby 3.1
-        return unless node.params
+        params = node.params
+        return unless params
 
-        params_location = node.params.location
+        params_location = params.location
 
         if params_location.start_line < params_location.end_line
           add_lines_range(params_location.end_line, node.location.end_line - 1)
@@ -253,7 +278,9 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
       def add_statements_range(node, statements)
-        add_lines_range(node.location.start_line, statements.body.last.location.end_line) unless statements.empty?
+        return if statements.empty?
+
+        add_lines_range(node.location.start_line, T.must(statements.body.last).location.end_line)
       end
 
       sig { params(node: SyntaxTree::StringConcat).void }
@@ -268,7 +295,7 @@ module RubyLsp
       def add_lines_range(start_line, end_line)
         return if start_line >= end_line
 
-        @ranges << LanguageServer::Protocol::Interface::FoldingRange.new(
+        @ranges << Interface::FoldingRange.new(
           start_line: start_line - 1,
           end_line: end_line - 1,
           kind: "region",

data/lib/ruby_lsp/requests/formatting.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/rubocop_formatting_runner"
+require "ruby_lsp/requests/support/syntax_tree_formatting_runner"
 
 module RubyLsp
   module Requests
@@ -22,14 +23,23 @@ module RubyLsp
     # ```
     class Formatting < BaseRequest
       class Error < StandardError; end
+      class InvalidFormatter < StandardError; end
 
       extend T::Sig
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(document: Document, formatter: String).void }
+      def initialize(document, formatter: "auto")
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
+        @formatter = T.let(
+          if formatter == "auto"
+            defined?(Support::RuboCopFormattingRunner) ? "rubocop" : "syntax_tree"
+          else
+            formatter
+          end,
+          String,
+        )
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
@@ -60,10 +70,13 @@ module RubyLsp
 
       sig { returns(T.nilable(String)) }
       def formatted_file
-        if defined?(Support::RuboCopFormattingRunner)
+        case @formatter
+        when "rubocop"
           Support::RuboCopFormattingRunner.instance.run(@uri, @document)
+        when "syntax_tree"
+          Support::SyntaxTreeFormattingRunner.instance.run(@uri, @document)
         else
-          SyntaxTree.format(@document.source)
+          raise InvalidFormatter, "Unknown formatter: #{@formatter}"
         end
       end
     end

data/lib/ruby_lsp/requests/hover.rb

@@ -36,7 +36,7 @@ module RubyLsp
         @position = T.let(document.create_scanner.find_char_position(position), Integer)
       end
 
-      sig { override.returns(T.nilable(LanguageServer::Protocol::Interface::Hover)) }
+      sig { override.returns(T.nilable(Interface::Hover)) }
       def run
         return unless @document.parsed?
 
@@ -48,9 +48,10 @@ module RubyLsp
           message = target.message
           generate_rails_document_link_hover(message.value, message)
         when SyntaxTree::CallNode
-          return if target.message == :call
+          message = target.message
+          return if message.is_a?(Symbol)
 
-          generate_rails_document_link_hover(target.message.value, target.message)
+          generate_rails_document_link_hover(message.value, message)
         when SyntaxTree::ConstPathRef
           constant_name = full_constant_name(target)
           generate_rails_document_link_hover(constant_name, target)
@@ -60,18 +61,18 @@ module RubyLsp
       private
 
       sig do
-        params(name: String, node: SyntaxTree::Node).returns(T.nilable(LanguageServer::Protocol::Interface::Hover))
+        params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover))
       end
       def generate_rails_document_link_hover(name, node)
         urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
 
         return if urls.empty?
 
-        contents = LanguageServer::Protocol::Interface::MarkupContent.new(
+        contents = Interface::MarkupContent.new(
           kind: "markdown",
           value: urls.join("\n\n"),
         )
-        LanguageServer::Protocol::Interface::Hover.new(
+        Interface::Hover.new(
           range: range_from_syntax_tree_node(node),
           contents: contents,
         )

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -25,11 +25,11 @@ module RubyLsp
       def initialize(document, range)
         super(document)
 
-        @hints = T.let([], T::Array[LanguageServer::Protocol::Interface::InlayHint])
+        @hints = T.let([], T::Array[Interface::InlayHint])
         @range = range
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::InlayHint], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::InlayHint], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @hints
@@ -37,12 +37,13 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Rescue).void }
       def visit_rescue(node)
-        return unless node.exception.nil?
+        exception = node.exception
+        return unless exception.nil? || exception.exceptions.nil?
 
         loc = node.location
         return unless visible?(node, @range)
 
-        @hints << LanguageServer::Protocol::Interface::InlayHint.new(
+        @hints << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
           label: "StandardError",
           padding_left: true,

data/lib/ruby_lsp/requests/path_completion.rb

@@ -63,13 +63,19 @@ module RubyLsp
 
         case matched
         when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
-          return unless matched.message.value == "require"
+          message = matched.message
+          return if message.is_a?(Symbol)
+          return unless message.value == "require"
 
           args = matched.arguments
           args = args.arguments if args.is_a?(SyntaxTree::ArgParen)
+          return if args.nil? || args.is_a?(SyntaxTree::ArgsForward)
 
-          path_node = args.parts.first.parts.first
-          return unless path_node
+          argument = args.parts.first
+          return unless argument.is_a?(SyntaxTree::StringLiteral)
+
+          path_node = argument.parts.first
+          return unless path_node.is_a?(SyntaxTree::TStringContent)
           return unless (path_node.location.start_char..path_node.location.end_char).cover?(position)
 
           path_node

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -100,12 +100,12 @@ module RubyLsp
       end
       def create_selection_range(location, parent = nil)
         RubyLsp::Requests::Support::SelectionRange.new(
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(
               line: location.start_line - 1,
               character: location.start_column,
             ),
-            end: LanguageServer::Protocol::Interface::Position.new(
+            end: Interface::Position.new(
               line: location.end_line - 1,
               character: location.end_column,
             ),

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -122,7 +122,7 @@ module RubyLsp
       sig do
         override.returns(
           T.any(
-            LanguageServer::Protocol::Interface::SemanticTokens,
+            Interface::SemanticTokens,
             T.all(T::Array[SemanticToken], Object),
           ),
         )
@@ -143,7 +143,7 @@ module RubyLsp
         visit(node.receiver)
 
         message = node.message
-        if message != :call && !special_method?(message.value)
+        if !message.is_a?(Symbol) && !special_method?(message.value)
           type = Support::Sorbet.annotation?(node) ? :type : :method
 
           add_token(message.location, type)
@@ -160,6 +160,7 @@ module RubyLsp
           add_token(node.message.location, :method)
         end
         visit(node.arguments)
+        visit(node.block)
       end
 
       sig { override.params(node: SyntaxTree::CommandCall).void }
@@ -167,8 +168,10 @@ module RubyLsp
         return super unless visible?(node, @range)
 
         visit(node.receiver)
-        add_token(node.message.location, :method)
+        message = node.message
+        add_token(message.location, :method) unless message.is_a?(Symbol)
         visit(node.arguments)
+        visit(node.block)
       end
 
       sig { override.params(node: SyntaxTree::Const).void }
@@ -203,7 +206,7 @@ module RubyLsp
       def visit_params(node)
         return super unless visible?(node, @range)
 
-        node.keywords.each do |keyword,|
+        node.keywords.each do |keyword, *|
           location = keyword.location
           add_token(location_without_colon(location), :parameter)
         end
@@ -213,7 +216,7 @@ module RubyLsp
         end
 
         rest = node.keyword_rest
-        if rest && !rest.is_a?(SyntaxTree::ArgsForward)
+        if rest && !rest.is_a?(SyntaxTree::ArgsForward) && !rest.is_a?(Symbol)
           name = rest.name
           add_token(name.location, :parameter) if name
         end
@@ -240,9 +243,13 @@ module RubyLsp
         when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
         else
           visit(value)
         end
+
+        super
       end
 
       sig { override.params(node: SyntaxTree::VarRef).void }
@@ -255,27 +262,84 @@ module RubyLsp
         when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
         else
           visit(value)
         end
       end
 
+      # All block locals are variables. E.g.: [].each do |x; block_local|
+      sig { override.params(node: SyntaxTree::BlockVar).void }
+      def visit_block_var(node)
+        node.locals.each { |local| add_token(local.location, :variable) }
+        super
+      end
+
+      # All lambda locals are variables. E.g.: ->(x; lambda_local) {}
+      sig { override.params(node: SyntaxTree::LambdaVar).void }
+      def visit_lambda_var(node)
+        node.locals.each { |local| add_token(local.location, :variable) }
+        super
+      end
+
       sig { override.params(node: SyntaxTree::VCall).void }
       def visit_vcall(node)
         return super unless visible?(node, @range)
 
-        return if special_method?(node.value.value)
+        # A VCall may exist as a local in the current_scope. This happens when used named capture groups in a regexp
+        ident = node.value
+        value = ident.value
+        local = current_scope.find_local(value)
+        return if local.nil? && special_method?(value)
+
+        type = if local
+          :variable
+        elsif Support::Sorbet.annotation?(node)
+          :type
+        else
+          :method
+        end
 
-        type = Support::Sorbet.annotation?(node) ? :type : :method
         add_token(node.value.location, type)
       end
 
+      sig { override.params(node: SyntaxTree::Binary).void }
+      def visit_binary(node)
+        # It's important to visit the regexp first in the WithScope module
+        super
+
+        # You can only capture local variables with regexp by using the =~ operator
+        return unless node.operator == :=~
+
+        left = node.left
+        # The regexp needs to be on the left hand side of the =~ for local variable capture
+        return unless left.is_a?(SyntaxTree::RegexpLiteral)
+
+        parts = left.parts
+        return unless parts.one?
+
+        content = parts.first
+        return unless content.is_a?(SyntaxTree::TStringContent)
+
+        # For each capture name we find in the regexp, look for a local in the current_scope
+        Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
+          local = current_scope.find_local(name)
+          next unless local
+
+          local.definitions.each { |definition| add_token(definition, :variable) }
+        end
+      end
+
       sig { override.params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
         return super unless visible?(node, @range)
 
         add_token(node.constant.location, :class, [:declaration])
-        add_token(node.superclass.location, :class) if node.superclass
+
+        superclass = node.superclass
+        add_token(superclass.location, :class) if superclass
+
         visit(node.bodystmt)
       end
 

data/lib/ruby_lsp/requests/support/highlight_target.rb

@@ -7,8 +7,8 @@ module RubyLsp
       class HighlightTarget
         extend T::Sig
 
-        READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
-        WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+        READ = Constant::DocumentHighlightKind::READ
+        WRITE = Constant::DocumentHighlightKind::WRITE
 
         class HighlightMatch
           extend T::Sig
@@ -84,10 +84,11 @@ module RubyLsp
                SyntaxTree::KwRestParam, SyntaxTree::BlockArg
             node.name&.value
           when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall
-            node.value&.value
+            value = node.value
+            value.value unless value.nil? || value.is_a?(Symbol)
           when SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
             message = node.message
-            message != :call ? message.value : nil
+            message.value unless message.is_a?(Symbol)
           when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
             node.constant.constant.value
           end