Merge pull request #16 from mtsmfm/jump-to-definition

Jump to definition

Author: mtsmfm

bin/console

@@ -6,6 +6,12 @@ require "language_server"
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
+def project
+  @project ||= LanguageServer::Project.new(
+    LanguageServer::FileStore.new(load_paths: $LOAD_PATH, remote_root: ENV['LANGUAGE_SERVER_RUBY_REMOTE_ROOT'], local_root: Dir.getwd)
+  )
+end
+
 # (If you use this, don't forget to add pry to your Gemfile!)
 require "pry-byebug"
 Pry.start

docker-compose.yml

@@ -4,6 +4,8 @@ services:
     build: &app-build
       context: .
       dockerfile: Dockerfile.development
+    environment:
+      LANGUAGE_SERVER_RUBY_REMOTE_ROOT: $PWD
     volumes:
       - mtsmfm-language-server-sync:/app:nocopy
       - home:/home/ruby

lib/language_server.rb

@@ -6,6 +6,7 @@
 require "language_server/linter/ruby_wc"
 require "language_server/completion_provider/rcodetools"
 require "language_server/completion_provider/ad_hoc"
+require "language_server/definition_provider/ad_hoc"
 require "language_server/file_store"
 require "language_server/project"
 
@@ -65,7 +66,8 @@ def on(method, &callback)
         completion_provider: Protocol::Interfaces::CompletionOptions.new(
           resolve_provider: true,
           trigger_characters: %w(.)
-        )
+        ),
+        definition_provider: true
       )
     )
   end
@@ -115,4 +117,13 @@ def on(method, &callback)
       CompletionProvider::Rcodetools.new(uri: uri, line: line, character: character, file_store: file_store)
     ].flat_map(&:call)
   end
+
+  on :"textDocument/definition" do |request:, project:|
+    uri = request[:params][:textDocument][:uri]
+    line, character = request[:params][:position].fetch_values(:line, :character).map(&:to_i)
+
+    [
+      DefinitionProvider::AdHoc.new(uri: uri, line: line, character: character, project: project),
+    ].flat_map(&:call)
+  end
 end

lib/language_server/definition_provider/ad_hoc.rb

@@ -0,0 +1,34 @@
+module LanguageServer
+  module DefinitionProvider
+    class AdHoc
+      def initialize(uri:, line:, character:, project:)
+        @uri = uri
+        @line = line
+        @character = character
+        @project = project
+      end
+
+      def call
+        project.find_definitions(uri: uri, line: line, character: character).map do |n|
+          Protocol::Interfaces::Location.new(
+            uri: "file://#{n.remote_path}",
+            range: Protocol::Interfaces::Range.new(
+              start: Protocol::Interfaces::Position.new(
+                line: n.lines.begin,
+                character: 0
+              ),
+              end: Protocol::Interfaces::Position.new(
+                line: n.lines.end,
+                character: 0
+              )
+            )
+          )
+        end
+      end
+
+      private
+
+      attr_reader :uri, :line, :character, :project
+    end
+  end
+end

lib/language_server/project.rb

@@ -9,9 +9,19 @@ def initialize(file_store)
       fetch_result
     end
 
+    def find_definitions(uri:, line:, character:)
+      result = result_store[file_store.path_from_remote_uri(uri)]
+
+      ref = result.refs.select {|node| node.lines.include?(line) && node.characters.include?(character) }.min_by {|node| node.characters.size }
+
+      return [] unless ref
+
+      lazy_modules.select {|n| n.full_name == ref.full_name }.force + lazy_classes.select {|n| n.full_name == ref.full_name }.force
+    end
+
     def recalculate_result(uri)
       path = file_store.path_from_remote_uri(uri)
-      result_store[path] = calculate(file_store.read(path), path)
+      calculate(file_store.read(path), path)
     end
 
     def constants(uri: nil, line: nil, character: nil)
@@ -50,7 +60,7 @@ def lazy_classes
 
     def fetch_result
       file_store.each {|content, path|
-        result_store[path] = calculate(content, path)
+        calculate(content, path)
       }
     end
 
@@ -61,7 +71,14 @@ def find_nearest_node(uri:, line:, character:)
     end
 
     def calculate(content, path)
-      Parser.parse(content, path)
+      begin
+        result = Parser.parse(content, path)
+      rescue => e
+        LanguageServer.logger.warn("Parse failed (local: #{path.local_path}, remote: #{path.remote_path})")
+        LanguageServer.logger.warn(e)
+      end
+
+      result_store[path] = result if result
     end
   end
 end

lib/language_server/project/node.rb

@@ -92,5 +92,69 @@ def inspect
         "<Class #{full_name}#L#{lines.begin}-#{lines.end}>"
       end
     end
+
+    class VarRef < Node
+      attributes :node
+
+      def lines
+        node.lineno..node.lineno
+      end
+
+      def characters
+        node.character..(character - 1)
+      end
+
+      def unshift_namespace(class_or_module)
+        node.unshift_namespace(class_or_module) if node.respond_to?(:unshift_namespace)
+      end
+
+      def names
+        node.names
+      end
+
+      def name
+        node.name
+      end
+
+      def full_name
+        names.join('::')
+      end
+
+      def inspect
+        "<VarRef #{full_name}#L#{lineno}(#{characters})>"
+      end
+    end
+
+    class ConstPathRef < Node
+      attributes :nodes
+
+      def lines
+        (nodes.first.lineno)..(nodes.last.lineno)
+      end
+
+      def characters
+        (nodes.first.characters.begin)..(nodes.last.character)
+      end
+
+      def unshift_namespace(class_or_module)
+        nodes.first.unshift_namespace(class_or_module)
+      end
+
+      def name
+        nodes.last.name
+      end
+
+      def names
+        nodes.flat_map(&:names)
+      end
+
+      def full_name
+        names.join('::')
+      end
+
+      def inspect
+        "<ConstPathRef #{full_name}#L#{lineno}(#{characters})>"
+      end
+    end
   end
 end

lib/language_server/project/parser.rb

@@ -5,12 +5,13 @@ module LanguageServer
   class Project
     class Parser < Ripper
       class Result
-        attr_reader :constants, :classes, :modules
+        attr_reader :constants, :classes, :modules, :refs
 
         def initialize
           @constants = []
           @classes = []
           @modules = []
+          @refs = []
         end
       end
 
@@ -40,10 +41,34 @@ def lineno
         super - 1
       end
 
+      def on_var_ref(node)
+        if node.instance_of?(Constant)
+          build_node(VarRef, node: node).tap do |n|
+            result.refs << n
+          end
+        else
+          node
+        end
+      end
+
+      def on_const_path_ref(*nodes)
+        if nodes.all? {|n| [Constant, ConstPathRef, VarRef].include?(n.class) }
+          build_node(ConstPathRef, nodes: nodes).tap do |n|
+            result.refs << n
+          end
+        else
+          nodes
+        end
+      end
+
       def on_const(name)
         build_node(Constant, namespaces: [], name: name, value: nil)
       end
 
+      def on_def(*args)
+        args.flatten.compact
+      end
+
       def on_int(value)
         build_node(LiteralValue, value: value.to_i)
       end
@@ -60,15 +85,17 @@ def on_assign(left, right)
       end
 
       def on_module(constant, children)
-        cn = children.select {|child| child.instance_of?(Constant) || child.instance_of?(Module) || child.instance_of?(Class)}
+        cn = children.select {|child| child.respond_to?(:unshift_namespace) }
+
         build_node(Module, constant: constant, children: cn).tap do |m|
           result.modules << m
           cn.each {|child| child.unshift_namespace(m) }
         end
       end
 
       def on_class(constant, superclass, children)
-        cn = children.select {|child| child.instance_of?(Constant) || child.instance_of?(Module) || child.instance_of?(Class)}
+        cn = children.select {|child| child.respond_to?(:unshift_namespace) }
+
         build_node(Class, constant: constant, superclass: superclass, children: cn).tap do |c|
           result.classes << c
           cn.each {|child| child.unshift_namespace(c) }

test/language_server/project/parser_test.rb

@@ -62,6 +62,69 @@ def initialize
 
         assert { result.modules.map(&:full_name) == %w(Hi) }
       end
+
+      def test_ref
+        result = Parser.parse(<<-EOS.strip_heredoc)
+          A
+        EOS
+
+        assert { result.refs.map {|r| [r.full_name, r.characters] } == [['A', 0..1]] }
+      end
+
+      def test_ref_2
+        result = Parser.parse(<<-EOS.strip_heredoc)
+          A::B
+        EOS
+
+        assert { result.refs.map {|r| [r.full_name, r.characters] } == [['A', 0..2], ['A::B', 0..3]] }
+      end
+
+      def test_ref_3
+        result = Parser.parse(<<-EOS.strip_heredoc)
+          A::B::C
+        EOS
+
+        assert { result.refs.map {|r| [r.full_name, r.characters] } == [['A', 0..2], ['A::B', 0..3], ['A::B::C', 0..6]] }
+      end
+
+      def test_ref_within_module
+        result = Parser.parse(<<-EOS.strip_heredoc)
+          module A
+            B
+          end
+        EOS
+
+        assert { result.refs.map {|r| [r.full_name, r.characters] } == [['A::B', 2..3]] }
+
+        result = Parser.parse(<<-EOS.strip_heredoc)
+          module A
+            B::C
+          end
+        EOS
+
+        assert { result.refs.map {|r| [r.full_name, r.characters] } == [['A::B', 2..4], ['A::B::C', 2..5]] }
+      end
+
+      def test_const_ref_with_method
+        result = Parser.parse(<<-EOS.strip_heredoc)
+          class.self::FOO
+        EOS
+
+        assert { result.refs == [] }
+      end
+
+      def test_inline_nested_class
+        result = Parser.parse(<<-EOS.strip_heredoc)
+          module A
+            module B
+              class C::D::E
+              end
+            end
+          end
+        EOS
+
+        assert { result.classes.map(&:full_name) == %w(A::B::C::D::E) }
+      end
     end
   end
 end

test/language_server/project_test.rb

@@ -46,5 +46,32 @@ def hi
       assert { project.classes(uri: uri, line: 1, character: 0).map(&:full_name).uniq.sort == %w(A B).sort }
       assert { project.classes(uri: uri, line: 2, character: 0).map(&:full_name).uniq.sort == %w(A B A::A::C).sort }
     end
+
+    def test_find_definition
+      store = FileStore.new
+      store.cache('file:///a.rb', <<-EOS.strip_heredoc)
+        class A
+          module A
+            class C
+              def foo
+              end
+            end
+          end
+        end
+      EOS
+
+      store.cache('file:///b.rb', <<-EOS.strip_heredoc)
+        class A
+          def hi
+            A::C.foo
+          end
+        end
+      EOS
+
+      project = Project.new(store)
+
+      assert { project.find_definitions(uri: 'file:///b.rb', line: 2, character: 6).first.full_name == 'A::A' }
+      assert { project.find_definitions(uri: 'file:///b.rb', line: 2, character: 7).first.full_name == 'A::A::C' }
+    end
   end
 end