syntax_tree 2.7.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e90bde4f4aa60ce6784fd2c03234853bc281b7012cdb496d3f2bd97a1d825a9
-  data.tar.gz: 24c4a344934acc5fb0b8b7d8931f689f98185f00fd9b71726f5aeab2499dea98
+  metadata.gz: 28783cde4387bbc7d38d9de500564804cd885733abe59e017be73ce04981a854
+  data.tar.gz: 6a54750102b8978df75e7f8a7d611e596067bb69863f91d5a8daa9aec8509c31
 SHA512:
-  metadata.gz: 70d191270dbe2efd07300169410e4e0674b7abd8ec1ed4d95e87f7bb986b790195f8366f27b77f38eeeb94de1a08ce3467d64fbb126910922857366389ce66c0
-  data.tar.gz: c3994813de2fa53eb132dce7e4d176e58a83071232bcdefe3ded77a3fdd35ed52639d99989878b4cf5ca3d13c0a5bc14cbdfb95555b9705e2dd08c88d2abf360
+  metadata.gz: c2f61f01bfa53604686798c96a53d8c98abd30145038db3b7f73f92c5c6b282447f3fe355382f6b3325b3ee98ce60ddcc5c102234b78e9c8d1fe9cbf006cb38d
+  data.tar.gz: e5a63e7fdc4f7e70e354a5861e42b8c0dffbbd2ffde38754c0a1fca8a6033be2deecd52ea3ec5fb7a2aa05e0d07ab93d3b4d69762ca3c911f36a6e898ef2ffaf

data/CHANGELOG.md

@@ -6,6 +6,35 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [3.0.0] - 2022-07-04
+
+### Changed
+
+- [#102](https://github.com/ruby-syntax-tree/syntax_tree/issues/102) - Handle requests to the language server for files that do not yet exist on disk.
+
+### Removed
+
+- [#108](https://github.com/ruby-syntax-tree/syntax_tree/pull/108) - Remove old inlay hints code.
+
+## [2.9.0] - 2022-07-04
+
+### Added
+
+- [#106](https://github.com/ruby-syntax-tree/syntax_tree/pull/106) - Add inlay hint support to match the LSP specification.
+
+## [2.8.0] - 2022-06-21
+
+### Added
+
+- [#95](https://github.com/ruby-syntax-tree/syntax_tree/pull/95) - The `HeredocEnd` node has been added which effectively results in the ability to determine the location of the ending of a heredoc from source.
+- [#99](https://github.com/ruby-syntax-tree/syntax_tree/pull/99) - The LSP now allows you to pass the same configuration options as the other CLI commands which allows formatting to be modified in the VSCode extension.
+- [#100](https://github.com/ruby-syntax-tree/syntax_tree/pull/100) - The LSP now explicitly responds to the shutdown request so that VSCode never deadlocks.
+
+### Changed
+
+- [#96](https://github.com/ruby-syntax-tree/syntax_tree/pull/96) - The CLI now runs in parallel by default. There is a worker created for each processor on the running machine (as determined by `Etc.nprocessors`).
+- [#97](https://github.com/ruby-syntax-tree/syntax_tree/pull/97) - Syntax Tree now handles the case where `DidYouMean` is not available for whatever reason, as well as handles the newer `detailed_message` API for errors.
+
 ## [2.7.1] - 2022-05-25
 
 ### Added
@@ -259,7 +288,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - 🎉 Initial release! 🎉
 
-[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.7.1...HEAD
+[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.9.0...HEAD
+[2.9.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.8.0...v2.9.0
+[2.8.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.7.1...v2.8.0
 [2.7.1]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.7.0...v2.7.1
 [2.7.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.6.0...v2.7.0
 [2.6.0]: https://github.com/ruby-syntax-tree/syntax_tree/compare/v2.5.0...v2.6.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_tree (2.7.1)
+    syntax_tree (3.0.0)
       prettier_print
 
 GEM
@@ -9,25 +9,27 @@ GEM
   specs:
     ast (2.4.2)
     docile (1.4.0)
-    minitest (5.15.0)
+    json (2.6.2)
+    minitest (5.16.2)
     parallel (1.22.1)
     parser (3.1.2.0)
       ast (~> 2.4.1)
     prettier_print (0.1.0)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.4.0)
+    regexp_parser (2.5.0)
     rexml (3.2.5)
-    rubocop (1.29.1)
+    rubocop (1.31.1)
+      json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.17.0, < 2.0)
+      rubocop-ast (>= 1.18.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.17.0)
+    rubocop-ast (1.18.0)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
     simplecov (0.21.2)
@@ -36,7 +38,7 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    unicode-display_width (2.1.0)
+    unicode-display_width (2.2.0)
 
 PLATFORMS
   arm64-darwin-21

data/README.md

@@ -35,7 +35,7 @@ It is built with only standard library dependencies. It additionally ships with
   - [BasicVisitor](#basicvisitor)
 - [Language server](#language-server)
   - [textDocument/formatting](#textdocumentformatting)
-  - [textDocument/inlayHints](#textdocumentinlayhints)
+  - [textDocument/inlayHint](#textdocumentinlayhint)
   - [syntaxTree/visualizing](#syntaxtreevisualizing)
 - [Plugins](#plugins)
   - [Configuration](#configuration)
@@ -402,7 +402,7 @@ By default, the language server is relatively minimal, mostly meant to provide a
 
 As mentioned above, the language server responds to formatting requests with the formatted document. It typically responds on the order of tens of milliseconds, so it should be fast enough for any IDE.
 
-### textDocument/inlayHints
+### textDocument/inlayHint
 
 The language server also responds to the relatively new inlay hints request. This request allows the language server to define additional information that should exist in the source code as helpful hints to the developer. In our case we use it to display things like implicit parentheses. For example, if you had the following code:
 
@@ -410,7 +410,7 @@ The language server also responds to the relatively new inlay hints request. Thi
 1 + 2 * 3
 ```
 
-Implicity, the `2 * 3` is going to be executed first because the `*` operator has higher precedence than the `+` operator. However, to ease mental overhead, our language server includes small parentheses to make this explicit, as in:
+Implicity, the `2 * 3` is going to be executed first because the `*` operator has higher precedence than the `+` operator. To ease mental overhead, our language server includes small parentheses to make this explicit, as in:
 
 ```ruby
 1 + ₍2 * 3₎

data/lib/syntax_tree/basic_visitor.rb

@@ -33,7 +33,11 @@ module SyntaxTree
           ).correct(visit_method)
       end
 
-      DidYouMean.correct_error(VisitMethodError, self)
+      # In some setups with Ruby you can turn off DidYouMean, so we're going to
+      # respect that setting here.
+      if defined?(DidYouMean) && DidYouMean.method_defined?(:correct_error)
+        DidYouMean.correct_error(VisitMethodError, self)
+      end
     end
 
     class << self

data/lib/syntax_tree/cli.rb

@@ -34,9 +34,41 @@ module SyntaxTree
       end
     end
 
+    # An item of work that corresponds to a file to be processed.
+    class FileItem
+      attr_reader :filepath
+
+      def initialize(filepath)
+        @filepath = filepath
+      end
+
+      def handler
+        HANDLERS[File.extname(filepath)]
+      end
+
+      def source
+        handler.read(filepath)
+      end
+    end
+
+    # An item of work that corresponds to the stdin content.
+    class STDINItem
+      def handler
+        HANDLERS[".rb"]
+      end
+
+      def filepath
+        :stdin
+      end
+
+      def source
+        $stdin.read
+      end
+    end
+
     # The parent action class for the CLI that implements the basics.
     class Action
-      def run(handler, filepath, source)
+      def run(item)
       end
 
       def success
@@ -48,8 +80,8 @@ module SyntaxTree
 
     # An action of the CLI that prints out the AST for the given source.
     class AST < Action
-      def run(handler, _filepath, source)
-        pp handler.parse(source)
+      def run(item)
+        pp item.handler.parse(item.source)
       end
     end
 
@@ -59,10 +91,11 @@ module SyntaxTree
       class UnformattedError < StandardError
       end
 
-      def run(handler, filepath, source)
-        raise UnformattedError if source != handler.format(source)
+      def run(item)
+        source = item.source
+        raise UnformattedError if source != item.handler.format(source)
       rescue StandardError
-        warn("[#{Color.yellow("warn")}] #{filepath}")
+        warn("[#{Color.yellow("warn")}] #{item.filepath}")
         raise
       end
 
@@ -81,9 +114,11 @@ module SyntaxTree
       class NonIdempotentFormatError < StandardError
       end
 
-      def run(handler, filepath, source)
-        warning = "[#{Color.yellow("warn")}] #{filepath}"
-        formatted = handler.format(source)
+      def run(item)
+        handler = item.handler
+
+        warning = "[#{Color.yellow("warn")}] #{item.filepath}"
+        formatted = handler.format(item.source)
 
         raise NonIdempotentFormatError if formatted != handler.format(formatted)
       rescue StandardError
@@ -102,25 +137,27 @@ module SyntaxTree
 
     # An action of the CLI that prints out the doc tree IR for the given source.
     class Doc < Action
-      def run(handler, _filepath, source)
+      def run(item)
+        source = item.source
+
         formatter = Formatter.new(source, [])
-        handler.parse(source).format(formatter)
+        item.handler.parse(source).format(formatter)
         pp formatter.groups.first
       end
     end
 
     # An action of the CLI that formats the input source and prints it out.
     class Format < Action
-      def run(handler, _filepath, source)
-        puts handler.format(source)
+      def run(item)
+        puts item.handler.format(item.source)
       end
     end
 
     # An action of the CLI that converts the source into its equivalent JSON
     # representation.
     class Json < Action
-      def run(handler, _filepath, source)
-        object = Visitor::JSONVisitor.new.visit(handler.parse(source))
+      def run(item)
+        object = Visitor::JSONVisitor.new.visit(item.handler.parse(item.source))
         puts JSON.pretty_generate(object)
       end
     end
@@ -128,27 +165,28 @@ module SyntaxTree
     # An action of the CLI that outputs a pattern-matching Ruby expression that
     # would match the input given.
     class Match < Action
-      def run(handler, _filepath, source)
-        puts handler.parse(source).construct_keys
+      def run(item)
+        puts item.handler.parse(item.source).construct_keys
       end
     end
 
     # An action of the CLI that formats the input source and writes the
     # formatted output back to the file.
     class Write < Action
-      def run(handler, filepath, source)
-        print filepath
+      def run(item)
+        filepath = item.filepath
         start = Time.now
 
-        formatted = handler.format(source)
+        source = item.source
+        formatted = item.handler.format(source)
         File.write(filepath, formatted) if filepath != :stdin
 
         color = source == formatted ? Color.gray(filepath) : filepath
         delta = ((Time.now - start) * 1000).round
 
-        puts "\r#{color} #{delta}ms"
+        puts "#{color} #{delta}ms"
       rescue StandardError
-        puts "\r#{filepath}"
+        puts filepath
         raise
       end
     end
@@ -180,7 +218,7 @@ module SyntaxTree
       #{Color.bold("stree help")}
         Display this help message
 
-      #{Color.bold("stree lsp")}
+      #{Color.bold("stree lsp [OPTIONS]")}
         Run syntax tree in language server mode
 
       #{Color.bold("stree version")}
@@ -201,6 +239,20 @@ module SyntaxTree
       def run(argv)
         name, *arguments = argv
 
+        # If there are any plugins specified on the command line, then load them
+        # by requiring them here. We do this by transforming something like
+        #
+        #     stree format --plugins=haml template.haml
+        #
+        # into
+        #
+        #     require "syntax_tree/haml"
+        #
+        if arguments.first&.start_with?("--plugins=")
+          plugins = arguments.shift[/^--plugins=(.*)$/, 1]
+          plugins.split(",").each { |plugin| require "syntax_tree/#{plugin}" }
+        end
+
         case name
         when "help"
           puts HELP
@@ -244,38 +296,41 @@ module SyntaxTree
           return 1
         end
 
-        # If there are any plugins specified on the command line, then load them
-        # by requiring them here. We do this by transforming something like
-        #
-        #     stree format --plugins=haml template.haml
-        #
-        # into
-        #
-        #     require "syntax_tree/haml"
-        #
-        if arguments.first&.start_with?("--plugins=")
-          plugins = arguments.shift[/^--plugins=(.*)$/, 1]
-          plugins.split(",").each { |plugin| require "syntax_tree/#{plugin}" }
-        end
+        # We're going to build up a queue of items to process.
+        queue = Queue.new
 
-        # Track whether or not there are any errors from any of the files that
-        # we take action on so that we can properly clean up and exit.
-        errored = false
-
-        each_file(arguments) do |handler, filepath, source|
-          action.run(handler, filepath, source)
-        rescue Parser::ParseError => error
-          warn("Error: #{error.message}")
-          highlight_error(error, source)
-          errored = true
-        rescue Check::UnformattedError, Debug::NonIdempotentFormatError
-          errored = true
-        rescue StandardError => error
-          warn(error.message)
-          warn(error.backtrace)
-          errored = true
+        # If we're reading from stdin, then we'll just add the stdin object to
+        # the queue. Otherwise, we'll add each of the filepaths to the queue.
+        if $stdin.tty? || arguments.any?
+          arguments.each do |pattern|
+            Dir
+              .glob(pattern)
+              .each do |filepath|
+                queue << FileItem.new(filepath) if File.file?(filepath)
+              end
+          end
+        else
+          queue << STDINItem.new
         end
 
+        # At the end, we're going to return whether or not this worker ever
+        # encountered an error.
+        errored =
+          with_workers(queue) do |item|
+            action.run(item)
+            false
+          rescue Parser::ParseError => error
+            warn("Error: #{error.message}")
+            highlight_error(error, item.source)
+            true
+          rescue Check::UnformattedError, Debug::NonIdempotentFormatError
+            true
+          rescue StandardError => error
+            warn(error.message)
+            warn(error.backtrace)
+            true
+          end
+
         if errored
           action.failure
           1
@@ -287,22 +342,33 @@ module SyntaxTree
 
       private
 
-      def each_file(arguments)
-        if $stdin.tty? || arguments.any?
-          arguments.each do |pattern|
-            Dir
-              .glob(pattern)
-              .each do |filepath|
-                next unless File.file?(filepath)
-
-                handler = HANDLERS[File.extname(filepath)]
-                source = handler.read(filepath)
-                yield handler, filepath, source
-              end
+      def with_workers(queue)
+        # If the queue is just 1 item, then we're not going to bother going
+        # through the whole ceremony of parallelizing the work.
+        return yield queue.shift if queue.size == 1
+
+        workers =
+          Etc.nprocessors.times.map do
+            Thread.new do
+              # Propagate errors in the worker threads up to the parent thread.
+              Thread.current.abort_on_exception = true
+
+              # Track whether or not there are any errors from any of the files
+              # that we take action on so that we can properly clean up and
+              # exit.
+              errored = false
+
+              # While there is still work left to do, shift off the queue and
+              # process the item.
+              (errored ||= yield queue.shift) until queue.empty?
+
+              # At the end, we're going to return whether or not this worker
+              # ever encountered an error.
+              errored
+            end
           end
-        else
-          yield HANDLERS[".rb"], :stdin, $stdin.read
-        end
+
+        workers.inject(false) { |accum, thread| accum || thread.value }
       end
 
       # Highlights a snippet from a source and parse error.

data/lib/syntax_tree/formatter.rb

@@ -68,7 +68,9 @@ module SyntaxTree
         # going to just print out the node as it was seen in the source.
         doc =
           if leading.last&.ignore?
-            text(source[node.location.start_char...node.location.end_char])
+            range = source[node.location.start_char...node.location.end_char]
+            separator = -> { breakable(indent: false, force: true) }
+            seplist(range.split(/\r?\n/, -1), separator) { |line| text(line) }
           else
             node.format(self)
           end

data/lib/syntax_tree/language_server/inlay_hints.rb

@@ -2,20 +2,37 @@
 
 module SyntaxTree
   class LanguageServer
-    # This class provides inlay hints for the language server. It is loosely
-    # designed around the LSP spec, but existed before the spec was finalized so
-    # is a little different for now.
-    #
-    # For more information, see the spec here:
+    # This class provides inlay hints for the language server. For more
+    # information, see the spec here:
     # https://github.com/microsoft/language-server-protocol/issues/956.
-    #
     class InlayHints < Visitor
-      attr_reader :stack, :before, :after
+      # This represents a hint that is going to be displayed in the editor.
+      class Hint
+        attr_reader :line, :character, :label
+
+        def initialize(line:, character:, label:)
+          @line = line
+          @character = character
+          @label = label
+        end
+
+        # This is the shape that the LSP expects.
+        def to_json(*opts)
+          {
+            position: {
+              line: line,
+              character: character
+            },
+            label: label
+          }.to_json(*opts)
+        end
+      end
+
+      attr_reader :stack, :hints
 
       def initialize
         @stack = []
-        @before = Hash.new { |hash, key| hash[key] = +"" }
-        @after = Hash.new { |hash, key| hash[key] = +"" }
+        @hints = []
       end
 
       def visit(node)
@@ -97,7 +114,11 @@ module SyntaxTree
       #
       def visit_rescue(node)
         if node.exception.nil?
-          after[node.location.start_char + "rescue".length] << " StandardError"
+          hints << Hint.new(
+            line: node.location.start_line - 1,
+            character: node.location.start_column + "rescue".length,
+            label: " StandardError"
+          )
         end
 
         super
@@ -120,17 +141,20 @@ module SyntaxTree
         super
       end
 
-      def self.find(program)
-        visitor = new
-        visitor.visit(program)
-        visitor
-      end
-
       private
 
       def parentheses(location)
-        before[location.start_char] << "₍"
-        after[location.end_char] << "₎"
+        hints << Hint.new(
+          line: location.start_line - 1,
+          character: location.start_column,
+          label: "₍"
+        )
+
+        hints << Hint.new(
+          line: location.end_line - 1,
+          character: location.end_column,
+          label: "₎"
+        )
       end
     end
   end

data/lib/syntax_tree/language_server.rb

@@ -20,70 +20,60 @@ module SyntaxTree
       @output = output.binmode
     end
 
+    # rubocop:disable Layout/LineLength
     def run
       store =
         Hash.new do |hash, uri|
-          hash[uri] = File.binread(CGI.unescape(URI.parse(uri).path))
+          filepath = CGI.unescape(URI.parse(uri).path)
+          File.exist?(filepath) ? (hash[uri] = File.read(filepath)) : nil
         end
 
       while (headers = input.gets("\r\n\r\n"))
         source = input.read(headers[/Content-Length: (\d+)/i, 1].to_i)
         request = JSON.parse(source, symbolize_names: true)
 
+        # stree-ignore
         case request
         in { method: "initialize", id: }
           store.clear
           write(id: id, result: { capabilities: capabilities })
-        in method: "initialized"
+        in { method: "initialized" }
           # ignored
-        in method: "shutdown"
+        in { method: "shutdown" } # tolerate missing ID to be a good citizen
           store.clear
+          write(id: request[:id], result: {})
           return
-        in {
-             method: "textDocument/didChange",
-             params: { textDocument: { uri: }, contentChanges: [{ text: }, *] }
-           }
+        in { method: "textDocument/didChange", params: { textDocument: { uri: }, contentChanges: [{ text: }, *] } }
           store[uri] = text
-        in {
-             method: "textDocument/didOpen",
-             params: { textDocument: { uri:, text: } }
-           }
+        in { method: "textDocument/didOpen", params: { textDocument: { uri:, text: } } }
           store[uri] = text
-        in {
-             method: "textDocument/didClose", params: { textDocument: { uri: } }
-           }
+        in { method: "textDocument/didClose", params: { textDocument: { uri: } } }
           store.delete(uri)
-        in {
-             method: "textDocument/formatting",
-             id:,
-             params: { textDocument: { uri: } }
-           }
-          write(id: id, result: [format(store[uri])])
-        in {
-             method: "textDocument/inlayHints",
-             id:,
-             params: { textDocument: { uri: } }
-           }
-          write(id: id, result: inlay_hints(store[uri]))
-        in {
-             method: "syntaxTree/visualizing",
-             id:,
-             params: { textDocument: { uri: } }
-           }
+        in { method: "textDocument/formatting", id:, params: { textDocument: { uri: } } }
+          contents = store[uri]
+          write(id: id, result: contents ? [format(store[uri])] : nil)
+        in { method: "textDocument/inlayHint", id:, params: { textDocument: { uri: } } }
+          contents = store[uri]
+          write(id: id, result: contents ? inlay_hints(store[uri]) : nil)
+        in { method: "syntaxTree/visualizing", id:, params: { textDocument: { uri: } } }
           write(id: id, result: PP.pp(SyntaxTree.parse(store[uri]), +""))
-        in method: %r{\$/.+}
+        in { method: %r{\$/.+} }
           # ignored
         else
           raise ArgumentError, "Unhandled: #{request}"
         end
       end
     end
+    # rubocop:enable Layout/LineLength
 
     private
 
     def capabilities
       {
         documentFormattingProvider: true,
+        inlayHintProvider: {
+          resolveProvider: false
+        },
         textDocumentSync: {
           change: 1,
           openClose: true
@@ -108,16 +98,13 @@ module SyntaxTree
     end
 
     def inlay_hints(source)
-      inlay_hints = InlayHints.find(SyntaxTree.parse(source))
-      serialize = ->(position, text) { { position: position, text: text } }
-
-      {
-        before: inlay_hints.before.map(&serialize),
-        after: inlay_hints.after.map(&serialize)
-      }
+      visitor = InlayHints.new
+      SyntaxTree.parse(source).accept(visitor)
+      visitor.hints
     rescue Parser::ParseError
       # If there is a parse error, then we're not going to return any inlay
       # hints for this source.
+      []
     end
 
     def write(value)

data/lib/syntax_tree/node.rb

@@ -4813,7 +4813,7 @@ module SyntaxTree
     # [HeredocBeg] the opening of the heredoc
     attr_reader :beginning
 
-    # [String] the ending of the heredoc
+    # [HeredocEnd] the ending of the heredoc
     attr_reader :ending
 
     # [Integer] how far to dedent the heredoc
@@ -4847,7 +4847,7 @@ module SyntaxTree
     end
 
     def child_nodes
-      [beginning, *parts]
+      [beginning, *parts, ending]
     end
 
     alias deconstruct child_nodes
@@ -4883,7 +4883,7 @@ module SyntaxTree
               end
             end
 
-            q.text(ending)
+            q.format(ending)
           end
         end
       end
@@ -4929,6 +4929,45 @@ module SyntaxTree
     end
   end
 
+  # HeredocEnd represents the closing declaration of a heredoc.
+  #
+  #     <<~DOC
+  #       contents
+  #     DOC
+  #
+  # In the example above the HeredocEnd node represents the closing DOC.
+  class HeredocEnd < Node
+    # [String] the closing declaration of the heredoc
+    attr_reader :value
+
+    # [Array[ Comment | EmbDoc ]] the comments attached to this node
+    attr_reader :comments
+
+    def initialize(value:, location:, comments: [])
+      @value = value
+      @location = location
+      @comments = comments
+    end
+
+    def accept(visitor)
+      visitor.visit_heredoc_end(self)
+    end
+
+    def child_nodes
+      []
+    end
+
+    alias deconstruct child_nodes
+
+    def deconstruct_keys(_keys)
+      { value: value, location: location, comments: comments }
+    end
+
+    def format(q)
+      q.text(value)
+    end
+  end
+
   # HshPtn represents matching against a hash pattern using the Ruby 2.7+
   # pattern matching syntax.
   #

data/lib/syntax_tree/parser.rb

@@ -1640,9 +1640,19 @@ module SyntaxTree
     def on_heredoc_end(value)
       heredoc = @heredocs[-1]
 
+      location =
+        Location.token(
+          line: lineno,
+          char: char_pos,
+          column: current_column,
+          size: value.size + 1
+        )
+
+      heredoc_end = HeredocEnd.new(value: value.chomp, location: location)
+
       @heredocs[-1] = Heredoc.new(
         beginning: heredoc.beginning,
-        ending: value.chomp,
+        ending: heredoc_end,
         dedent: heredoc.dedent,
         parts: heredoc.parts,
         location:

data/lib/syntax_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxTree
-  VERSION = "2.7.1"
+  VERSION = "3.0.0"
 end

data/lib/syntax_tree/visitor/field_visitor.rb

@@ -497,6 +497,10 @@ module SyntaxTree
         visit_token(node, "heredoc_beg")
       end
 
+      def visit_heredoc_end(node)
+        visit_token(node, "heredoc_end")
+      end
+
       def visit_hshptn(node)
         node(node, "hshptn") do
           field("constant", node.constant) if node.constant

data/lib/syntax_tree/visitor.rb

@@ -194,6 +194,9 @@ module SyntaxTree
     # Visit a HeredocBeg node.
     alias visit_heredoc_beg visit_child_nodes
 
+    # Visit a HeredocEnd node.
+    alias visit_heredoc_end visit_child_nodes
+
     # Visit a HshPtn node.
     alias visit_hshptn visit_child_nodes
 

data/lib/syntax_tree.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "etc"
 require "json"
 require "pp"
 require "prettier_print"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-25 00:00:00.000000000 Z
+date: 2022-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -160,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: A parser based on ripper