Store the parsed tree to avoid unnecessary re-parsing

lib/ruby/lsp/requests/folding_ranges.rb

@@ -4,13 +4,12 @@ module Ruby
   module Lsp
     module Requests
       class FoldingRanges
-        def self.run(source)
-          new(source).run
+        def self.run(item)
+          new(item).run
         end
 
-        def initialize(source)
-          @parser = SyntaxTree.new(source)
-          @queue = [@parser.parse]
+        def initialize(item)
+          @queue = [item.tree]
           @ranges = []
         end
 

lib/ruby/lsp/store.rb

@@ -11,11 +11,17 @@ def initialize
       end
 
       def [](uri)
-        @state[uri] || File.binread(CGI.unescape(URI.parse(uri).path))
+        item = @state[uri]
+        return item unless item.nil?
+
+        self[uri] = File.binread(CGI.unescape(URI.parse(uri).path))
+        @state[uri]
       end
 
       def []=(uri, content)
-        @state[uri] = content
+        @state[uri] = Item.new(content)
+      rescue SyntaxTree::ParseError
+        # Do not update the store if there are syntax errors
       end
 
       def clear
@@ -25,6 +31,20 @@ def clear
       def delete(uri)
         @state.delete(uri)
       end
+
+      class Item
+        attr_reader :tree, :parser, :source
+
+        def initialize(source)
+          @source = source
+          @parser = SyntaxTree.new(source)
+          @tree = @parser.parse
+        end
+
+        def ==(other)
+          @source == other.source
+        end
+      end
     end
   end
 end

test/requests/folding_ranges_test.rb

@@ -16,7 +16,8 @@ def foo
   private
 
   def assert_ranges(source, expected_ranges)
-    actual = Ruby::Lsp::Requests::FoldingRanges.run(source)
+    item = Ruby::Lsp::Store::Item.new(source)
+    actual = Ruby::Lsp::Requests::FoldingRanges.run(item)
     assert_equal(expected_ranges, JSON.parse(actual.to_json, symbolize_names: true))
   end
 end

test/store_test.rb

@@ -5,35 +5,43 @@
 class StoreTest < Minitest::Test
   def test_hash_accessors
     store = Ruby::Lsp::Store.new
-    store["/foo/bar.rb"] = "foo"
+    store["/foo/bar.rb"] = "def foo; end"
 
-    assert_equal("foo", store["/foo/bar.rb"])
+    assert_equal(Ruby::Lsp::Store::Item.new("def foo; end"), store["/foo/bar.rb"])
   end
 
   def test_reads_from_file_if_missing_in_store
     store = Ruby::Lsp::Store.new
 
     file = Tempfile.new("foo.rb")
-    file.write("some great code")
+    file.write("def great_code; end")
     file.rewind
 
-    assert_equal("some great code", store[file.path])
+    assert_equal(Ruby::Lsp::Store::Item.new("def great_code; end"), store[file.path])
   ensure
     file.close
     file.unlink
   end
 
+  def test_store_ignores_syntax_errors
+    store = Ruby::Lsp::Store.new
+    store["/foo/bar.rb"] = "def foo; end"
+    store["/foo/bar.rb"] = "def bar; end; end"
+
+    assert_equal(Ruby::Lsp::Store::Item.new("def foo; end"), store["/foo/bar.rb"])
+  end
+
   def test_clear
     store = Ruby::Lsp::Store.new
-    store["/foo/bar.rb"] = "foo"
+    store["/foo/bar.rb"] = "def foo; end"
     store.clear
 
     assert_empty(store.instance_variable_get(:@state))
   end
 
   def test_delete
     store = Ruby::Lsp::Store.new
-    store["/foo/bar.rb"] = "foo"
+    store["/foo/bar.rb"] = "def foo; end"
     store.delete("/foo/bar.rb")
 
     assert_empty(store.instance_variable_get(:@state))