ruby-lsp 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab0e94532c080cf6e443c95d9ca7ccb16f548ec45768dc58e95fd691c907a965
-  data.tar.gz: 856df7b413ef111e100ee42da541856843d966184f9dbe1dfe2ee5a50da1e802
+  metadata.gz: 2b072ffa3ea73a83aba6d6c32b931c4de30b0de06fd70655d620c3ed95bd8aa4
+  data.tar.gz: 24568688b20ffed38defcbc0b00708eb22a7dad20a9b5f397348242a64359bfd
 SHA512:
-  metadata.gz: fde4cd9c5e556ff926b22d316d1bfcc5d31c089850d4558ac7d954fe33df4c8d2b8f8c14e55d1dcc2898087d0d29e8b12fc2f768e2b14935fa727f9620ff5c9e
-  data.tar.gz: 24fb12213f36edcee13fe65d53a94977737b251566d2503dc857dc276192d6f570f93147f57fc5e3b23c8d90b2c1f96f4cc7e308d5b969a02705d39444676f95
+  metadata.gz: ea1830f0be08cb291e67d80bbe21dbe17f3e4b4d285b1d9112e004ca2feff32eaca85af755bc2635e3341ab4e64491710c3ba13c5bed617e34495534e1d7a5f8
+  data.tar.gz: f84b1b27c5c17455d1e8423f1e52f98a754ed123e1722bd536ee7bfdc754952e5d6619c0f4402664a33dc278bdc2422a3e7a37c8de5f172e4456e7a6c08b7a67

data/.rubocop.yml

@@ -25,6 +25,15 @@ Sorbet/FalseSigil:
 Sorbet/TrueSigil:
   Enabled: true
   Include:
-    - "**/*.rb"
+    - "test/**/*.rb"
   Exclude:
     - "**/*.rake"
+    - "lib/**/*.rb"
+
+Sorbet/StrictSigil:
+  Enabled: true
+  Include:
+    - "lib/**/*.rb"
+  Exclude:
+    - "**/*.rake"
+    - "test/**/*.rb"

data/CHANGELOG.md

@@ -6,6 +6,16 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+## [0.1.0]
+
+- Implement token modifiers in SemanticTokenEncoder ([#112](https://github.com/Shopify/ruby-lsp/pull/112))
+- Add semantic token for name in a method definition ([#133](https://github.com/Shopify/ruby-lsp/pull/133))
+- Add semantic highighting for def endless and singleton method names ([#134](https://github.com/Shopify/ruby-lsp/pull/134))
+- Add semantic token for keyword self ([#137](https://github.com/Shopify/ruby-lsp/pull/137))
+- Add semantic token for constants ([#138](https://github.com/Shopify/ruby-lsp/pull/138))
+- Improve error handling + fix formatting hanging issue ([#149](https://github.com/Shopify/ruby-lsp/pull/149))
+- Set the minimum syntax_tree version to 2.4 ([#151](https://github.com/Shopify/ruby-lsp/pull/151))
+
 ## [0.0.4]
 
 - Add basic document highlight (https://github.com/Shopify/ruby-lsp/pull/91)

data/Gemfile

@@ -9,7 +9,7 @@ gem "minitest", "~> 5.15"
 gem "minitest-reporters", "~> 1.5"
 gem "rake", "~> 13.0"
 gem "rubocop-shopify", "~> 2.7", require: false
-gem "rubocop-minitest", "~> 0.20.0", require: false
+gem "rubocop-minitest", "~> 0.20.1", require: false
 gem "rubocop-rake", "~> 0.6.0", require: false
 gem "rubocop-sorbet", "~> 0.6", require: false
 gem "sorbet-static-and-runtime"

data/Gemfile.lock

@@ -1,11 +1,11 @@
 PATH
   remote: .
   specs:
-    ruby-lsp (0.0.4)
+    ruby-lsp (0.1.0)
       language_server-protocol
       rubocop (>= 1.0)
       sorbet-runtime
-      syntax_tree (>= 2.3)
+      syntax_tree (>= 2.4)
 
 GEM
   remote: https://rubygems.org/
@@ -47,7 +47,7 @@ GEM
     reline (0.3.1)
       io-console (~> 0.5)
     rexml (3.2.5)
-    rubocop (1.30.0)
+    rubocop (1.30.1)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
@@ -58,7 +58,7 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.18.0)
       parser (>= 3.1.1.0)
-    rubocop-minitest (0.20.0)
+    rubocop-minitest (0.20.1)
       rubocop (>= 0.90, < 2.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
@@ -67,14 +67,14 @@ GEM
     rubocop-sorbet (0.6.8)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.11.0)
-    sorbet (0.5.10073)
-      sorbet-static (= 0.5.10073)
-    sorbet-runtime (0.5.10073)
-    sorbet-static (0.5.10073-universal-darwin-21)
-    sorbet-static (0.5.10073-x86_64-linux)
-    sorbet-static-and-runtime (0.5.10073)
-      sorbet (= 0.5.10073)
-      sorbet-runtime (= 0.5.10073)
+    sorbet (0.5.10092)
+      sorbet-static (= 0.5.10092)
+    sorbet-runtime (0.5.10092)
+    sorbet-static (0.5.10092-universal-darwin-21)
+    sorbet-static (0.5.10092-x86_64-linux)
+    sorbet-static-and-runtime (0.5.10092)
+      sorbet (= 0.5.10092)
+      sorbet-runtime (= 0.5.10092)
     spoom (1.1.11)
       sorbet (>= 0.5.9204)
       sorbet-runtime (>= 0.5.9204)
@@ -111,7 +111,7 @@ DEPENDENCIES
   minitest (~> 5.15)
   minitest-reporters (~> 1.5)
   rake (~> 13.0)
-  rubocop-minitest (~> 0.20.0)
+  rubocop-minitest (~> 0.20.1)
   rubocop-rake (~> 0.6.0)
   rubocop-shopify (~> 2.7)
   rubocop-sorbet (~> 0.6)

data/README.md

@@ -50,7 +50,7 @@ To add a new expectations test runner for a new request handler:
    require "expectations/expectations_test_runner"
 
    class $HANDLERExpectationsTest < ExpectationsTestRunner
-    expectations_tests RubyLsp::Requests::$HANDLER, "$EXPECTATIONS_DIR"
+     expectations_tests RubyLsp::Requests::$HANDLER, "$EXPECTATIONS_DIR"
    end
    ```
 

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.0

data/exe/ruby-lsp

@@ -18,6 +18,6 @@ rescue
   nil
 end
 
-require_relative "../lib/internal"
+require_relative "../lib/ruby_lsp/internal"
 
 RubyLsp::Cli.start

data/lib/ruby-lsp.rb

@@ -1,6 +1,6 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
-  VERSION = File.read(File.expand_path("../VERSION", __dir__)).strip
+  VERSION = T.let(File.read(File.expand_path("../VERSION", __dir__)).strip, String)
 end

data/lib/ruby_lsp/document.rb

@@ -32,7 +32,13 @@ module RubyLsp
       @source == other.source
     end
 
-    sig { params(request_name: Symbol, block: T.proc.params(document: Document).returns(T.untyped)).returns(T.untyped) }
+    sig do
+      type_parameters(:T)
+        .params(
+          request_name: Symbol,
+          block: T.proc.params(document: Document).returns(T.type_parameter(:T))
+        ).returns(T.type_parameter(:T))
+    end
     def cache_fetch(request_name, &block)
       cached = @cache[request_name]
       return cached if cached

data/lib/ruby_lsp/handler.rb

@@ -28,9 +28,7 @@ module RubyLsp
     sig { void }
     def start
       $stderr.puts "Starting Ruby LSP..."
-      @reader.read do |request|
-        with_telemetry(request) { handle(request) }
-      end
+      @reader.read { |request| handle(request) }
     end
 
     sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
@@ -52,11 +50,23 @@ module RubyLsp
 
     sig { params(request: T::Hash[Symbol, T.untyped]).void }
     def handle(request)
+      result = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(StandardError))
       handler = @handlers[request[:method]]
-      return unless handler
 
-      result = handler.call(request)
-      @writer.write(id: request[:id], result: result) unless result == VOID
+      request_time = Benchmark.realtime do
+        if handler
+          begin
+            result = handler.call(request)
+          rescue StandardError => e
+            error = e
+          end
+
+          @writer.write(id: request[:id], result: result) unless result == VOID
+        end
+      end
+
+      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
     end
 
     sig { void }
@@ -114,14 +124,14 @@ module RubyLsp
     sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
     def respond_with_document_symbol(uri)
       store.cache_fetch(uri, :document_symbol) do |document|
-        RubyLsp::Requests::DocumentSymbol.run(document)
+        RubyLsp::Requests::DocumentSymbol.new(document).run
       end
     end
 
     sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::FoldingRange]) }
     def respond_with_folding_ranges(uri)
       store.cache_fetch(uri, :folding_ranges) do |document|
-        Requests::FoldingRanges.run(document)
+        Requests::FoldingRanges.new(document).run
       end
     end
 
@@ -129,11 +139,11 @@ module RubyLsp
       params(
         uri: String,
         positions: T::Array[Document::PositionShape]
-      ).returns(T::Array[RubyLsp::Requests::Support::SelectionRange])
+      ).returns(T::Array[T.nilable(RubyLsp::Requests::Support::SelectionRange)])
     end
     def respond_with_selection_ranges(uri, positions)
       ranges = store.cache_fetch(uri, :selection_ranges) do |document|
-        Requests::SelectionRanges.run(document)
+        Requests::SelectionRanges.new(document).run
       end
 
       # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
@@ -150,19 +160,22 @@ module RubyLsp
     sig { params(uri: String).returns(LanguageServer::Protocol::Interface::SemanticTokens) }
     def respond_with_semantic_highlighting(uri)
       store.cache_fetch(uri, :semantic_highlighting) do |document|
-        Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run
+        T.cast(
+          Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run,
+          LanguageServer::Protocol::Interface::SemanticTokens
+        )
       end
     end
 
-    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
+    sig { params(uri: String).returns(T.nilable(T::Array[LanguageServer::Protocol::Interface::TextEdit])) }
     def respond_with_formatting(uri)
-      Requests::Formatting.run(uri, store.get(uri))
+      Requests::Formatting.new(uri, store.get(uri)).run
     end
 
     sig { params(uri: String).void }
     def send_diagnostics(uri)
       response = store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.run(uri, document)
+        Requests::Diagnostics.new(uri, document).run
       end
 
       @writer.write(
@@ -175,11 +188,11 @@ module RubyLsp
     end
 
     sig do
-      params(uri: String, range: T::Range[Integer]).returns(T::Array[LanguageServer::Protocol::Interface::Diagnostic])
+      params(uri: String, range: T::Range[Integer]).returns(T::Array[LanguageServer::Protocol::Interface::CodeAction])
     end
     def respond_with_code_actions(uri, range)
       store.cache_fetch(uri, :code_actions) do |document|
-        Requests::CodeActions.run(uri, document, range)
+        Requests::CodeActions.new(uri, document, range).run
       end
     end
 
@@ -190,22 +203,7 @@ module RubyLsp
       ).returns(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
     end
     def respond_with_document_highlight(uri, position)
-      Requests::DocumentHighlight.run(store.get(uri), position)
-    end
-
-    sig { params(request: T::Hash[Symbol, T.untyped], block: T.proc.void).returns(T.untyped) }
-    def with_telemetry(request, &block)
-      result = T.let(nil, T.untyped)
-      error = T.let(nil, T.nilable(StandardError))
-
-      request_time = Benchmark.realtime do
-        result = block.call
-      rescue StandardError => e
-        error = e
-      end
-
-      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
-      result
+      Requests::DocumentHighlight.new(store.get(uri), position).run
     end
 
     sig do

data/lib/{internal.rb → ruby_lsp/internal.rb}

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "sorbet-runtime"

data/lib/ruby_lsp/requests/base_request.rb

@@ -1,24 +1,26 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     # :nodoc:
     class BaseRequest < SyntaxTree::Visitor
-      def self.run(document)
-        new(document).run
-      end
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
 
+      sig { params(document: Document).void }
       def initialize(document)
         @document = document
 
         super()
       end
 
-      def run
-        raise NotImplementedError, "#{self.class}#run must be implemented"
-      end
+      sig { abstract.returns(Object) }
+      def run; end
 
+      sig { params(node: SyntaxTree::Node).returns(LanguageServer::Protocol::Interface::Range) }
       def range_from_syntax_tree_node(node)
         loc = node.location
 

data/lib/ruby_lsp/requests/code_actions.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -14,23 +14,32 @@ module RubyLsp
     # puts "Hello" # --> code action: quick fix indentation
     # end
     # ```
-    class CodeActions
-      def self.run(uri, document, range)
-        new(uri, document, range).run
-      end
+    class CodeActions < BaseRequest
+      extend T::Sig
 
+      sig do
+        params(
+          uri: String,
+          document: Document,
+          range: T::Range[Integer]
+        ).void
+      end
       def initialize(uri, document, range)
-        @document = document
+        super(document)
+
         @uri = uri
         @range = range
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CodeAction], Object)) }
       def run
-        diagnostics = Diagnostics.run(@uri, @document)
-        corrections = diagnostics.select { |diagnostic| diagnostic.correctable? && diagnostic.in_range?(@range) }
+        diagnostics = Diagnostics.new(@uri, @document).run
+        corrections = diagnostics.select do |diagnostic|
+          diagnostic.correctable? && T.cast(diagnostic, Support::RuboCopDiagnostic).in_range?(@range)
+        end
         return [] if corrections.empty?
 
-        corrections.map!(&:to_lsp_code_action)
+        T.cast(corrections, T::Array[Support::RuboCopDiagnostic]).map!(&:to_lsp_code_action)
       end
     end
   end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -15,6 +15,16 @@ module RubyLsp
     # end
     # ```
     class Diagnostics < RuboCopRequest
+      extend T::Sig
+
+      sig do
+        override.returns(
+          T.any(
+            T.all(T::Array[Support::RuboCopDiagnostic], Object),
+            T.all(T::Array[Support::SyntaxErrorDiagnostic], Object),
+          )
+        )
+      end
       def run
         return syntax_error_diagnostics if @document.syntax_errors?
 
@@ -23,12 +33,14 @@ module RubyLsp
         @diagnostics
       end
 
+      sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
       def file_finished(_file, offenses)
         @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, @uri) }
       end
 
       private
 
+      sig { returns(T::Array[Support::SyntaxErrorDiagnostic]) }
       def syntax_error_diagnostics
         @document.syntax_error_edits.map { |e| Support::SyntaxErrorDiagnostic.new(e) }
       end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -21,18 +21,28 @@ module RubyLsp
     # end
     # ```
     class DocumentHighlight < BaseRequest
-      def self.run(document, position)
-        new(document, position).run
+      extend T::Sig
+
+      VarNodes = T.type_alias do
+        T.any(
+          SyntaxTree::GVar,
+          SyntaxTree::Ident,
+          SyntaxTree::IVar,
+          SyntaxTree::Const,
+          SyntaxTree::CVar
+        )
       end
 
+      sig { params(document: Document, position: Document::PositionShape).void }
       def initialize(document, position)
-        @highlights = []
+        @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
         position = Document::Scanner.new(document.source).find_position(position)
-        @target = find(document.tree, position)
+        @target = T.let(find(document.tree, position), T.nilable(VarNodes))
 
         super(document)
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight], Object)) }
       def run
         # no @target means the target is not highlightable
         return [] unless @target
@@ -41,6 +51,7 @@ module RubyLsp
         @highlights
       end
 
+      sig { params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
         if matches_target?(node.value)
           add_highlight(
@@ -52,6 +63,7 @@ module RubyLsp
         super
       end
 
+      sig { params(node: SyntaxTree::VarRef).void }
       def visit_var_ref(node)
         if matches_target?(node.value)
           add_highlight(
@@ -65,6 +77,7 @@ module RubyLsp
 
       private
 
+      sig { params(node: SyntaxTree::Node, position: Integer).returns(T.nilable(VarNodes)) }
       def find(node, position)
         matched =
           node.child_nodes.compact.bsearch do |child|
@@ -83,10 +96,12 @@ module RubyLsp
         end
       end
 
+      sig { params(node: SyntaxTree::Node).returns(T::Boolean) }
       def matches_target?(node)
-        node.is_a?(@target.class) && node.value == @target.value
+        node.is_a?(@target.class) && T.cast(node, VarNodes).value == T.must(@target).value
       end
 
+      sig { params(node: SyntaxTree::Node, kind: Integer).void }
       def add_highlight(node, kind)
         range = range_from_syntax_tree_node(node)
         @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: kind)

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -25,7 +25,9 @@ module RubyLsp
     # end
     # ```
     class DocumentSymbol < BaseRequest
-      SYMBOL_KIND = {
+      extend T::Sig
+
+      SYMBOL_KIND = T.let({
         file: 1,
         module: 2,
         namespace: 3,
@@ -52,33 +54,43 @@ module RubyLsp
         event: 24,
         operator: 25,
         typeparameter: 26,
-      }.freeze
+      }.freeze, T::Hash[Symbol, Integer])
 
-      ATTR_ACCESSORS = ["attr_reader", "attr_writer", "attr_accessor"].freeze
+      ATTR_ACCESSORS = T.let(["attr_reader", "attr_writer", "attr_accessor"].freeze, T::Array[String])
 
       class SymbolHierarchyRoot
+        extend T::Sig
+
+        sig { returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
         attr_reader :children
 
+        sig { void }
         def initialize
-          @children = []
+          @children = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentSymbol])
         end
       end
 
+      sig { params(document: Document).void }
       def initialize(document)
         super
 
-        @root = SymbolHierarchyRoot.new
-        @stack = [@root]
+        @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
+        @stack = T.let(
+          [@root],
+          T::Array[T.any(SymbolHierarchyRoot, LanguageServer::Protocol::Interface::DocumentSymbol)]
+        )
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol], Object)) }
       def run
         visit(@document.tree)
         @root.children
       end
 
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
         symbol = create_document_symbol(
-          name: node.constant.constant.value,
+          name: fully_qualified_name(node),
           kind: :class,
           range_node: node,
           selection_range_node: node.constant
@@ -89,6 +101,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::Command).void }
       def visit_command(node)
         return unless ATTR_ACCESSORS.include?(node.message.value)
 
@@ -104,6 +117,7 @@ module RubyLsp
         end
       end
 
+      sig { params(node: SyntaxTree::ConstPathField).void }
       def visit_const_path_field(node)
         create_document_symbol(
           name: node.constant.value,
@@ -113,6 +127,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::Def).void }
       def visit_def(node)
         name = node.name.value
 
@@ -128,6 +143,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::DefEndless).void }
       def visit_def_endless(node)
         name = node.name.value
 
@@ -143,6 +159,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::Defs).void }
       def visit_defs(node)
         symbol = create_document_symbol(
           name: "self.#{node.name.value}",
@@ -156,9 +173,10 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::ModuleDeclaration).void }
       def visit_module(node)
         symbol = create_document_symbol(
-          name: node.constant.constant.value,
+          name: fully_qualified_name(node),
           kind: :module,
           range_node: node,
           selection_range_node: node.constant
@@ -169,6 +187,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::TopConstField).void }
       def visit_top_const_field(node)
         create_document_symbol(
           name: node.constant.value,
@@ -178,6 +197,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
         kind = case node.value
         when SyntaxTree::Const
@@ -198,6 +218,14 @@ module RubyLsp
 
       private
 
+      sig do
+        params(
+          name: String,
+          kind: Symbol,
+          range_node: SyntaxTree::Node,
+          selection_range_node: SyntaxTree::Node
+        ).returns(LanguageServer::Protocol::Interface::DocumentSymbol)
+      end
       def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
         symbol = LanguageServer::Protocol::Interface::DocumentSymbol.new(
           name: name,
@@ -207,10 +235,29 @@ module RubyLsp
           children: [],
         )
 
-        @stack.last.children << symbol
+        T.must(@stack.last).children << symbol
 
         symbol
       end
+
+      sig { params(node: T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)).returns(String) }
+      def fully_qualified_name(node)
+        constant = T.let(node.constant, SyntaxTree::Node)
+        name = +node.constant.constant.value
+
+        while constant.is_a?(SyntaxTree::ConstPathRef)
+          constant = constant.parent
+
+          case constant
+          when SyntaxTree::ConstPathRef
+            name.prepend("#{constant.constant.value}::")
+          when SyntaxTree::VarRef
+            name.prepend("#{constant.value.value}::")
+          end
+        end
+
+        name
+      end
     end
   end
 end