syntax_tree 5.3.0 → 6.0.0

data/lib/syntax_tree/{visitor/field_visitor.rb → field_visitor.rb}

@@ -1,55 +1,54 @@
 # frozen_string_literal: true
 
 module SyntaxTree
-  class Visitor
-    # This is the parent class of a lot of built-in visitors for Syntax Tree. It
-    # reflects visiting each of the fields on every node in turn. It itself does
-    # not do anything with these fields, it leaves that behavior up to the
-    # subclass to implement.
-    #
-    # In order to properly use this class, you will need to subclass it and
-    # implement #comments, #field, #list, #node, #pairs, and #text. Those are
-    # documented here.
-    #
-    # == comments(node)
-    #
-    # This accepts the node that is being visited and does something depending
-    # on the comments attached to the node.
-    #
-    # == field(name, value)
-    #
-    # This accepts the name of the field being visited as a string (like
-    # "value") and the actual value of that field. The value can be a subclass
-    # of Node or any other type that can be held within the tree.
-    #
-    # == list(name, values)
-    #
-    # This accepts the name of the field being visited as well as a list of
-    # values. This is used, for example, when visiting something like the body
-    # of a Statements node.
-    #
-    # == node(name, node)
-    #
-    # This is the parent serialization method for each node. It is called with
-    # the node itself, as well as the type of the node as a string. The type
-    # is an internally used value that usually resembles the name of the
-    # ripper event that generated the node. The method should yield to the
-    # given block which then calls through to visit each of the fields on the
-    # node.
-    #
-    # == text(name, value)
-    #
-    # This accepts the name of the field being visited as well as a string
-    # value representing the value of the field.
-    #
-    # == pairs(name, values)
-    #
-    # This accepts the name of the field being visited as well as a list of
-    # pairs that represent the value of the field. It is used only in a couple
-    # of circumstances, like when visiting the list of optional parameters
-    # defined on a method.
-    #
-    class FieldVisitor < BasicVisitor
+  # This is the parent class of a lot of built-in visitors for Syntax Tree. It
+  # reflects visiting each of the fields on every node in turn. It itself does
+  # not do anything with these fields, it leaves that behavior up to the
+  # subclass to implement.
+  #
+  # In order to properly use this class, you will need to subclass it and
+  # implement #comments, #field, #list, #node, #pairs, and #text. Those are
+  # documented here.
+  #
+  # == comments(node)
+  #
+  # This accepts the node that is being visited and does something depending on
+  # the comments attached to the node.
+  #
+  # == field(name, value)
+  #
+  # This accepts the name of the field being visited as a string (like "value")
+  # and the actual value of that field. The value can be a subclass of Node or
+  # any other type that can be held within the tree.
+  #
+  # == list(name, values)
+  #
+  # This accepts the name of the field being visited as well as a list of
+  # values. This is used, for example, when visiting something like the body of
+  # a Statements node.
+  #
+  # == node(name, node)
+  #
+  # This is the parent serialization method for each node. It is called with the
+  # node itself, as well as the type of the node as a string. The type is an
+  # internally used value that usually resembles the name of the ripper event
+  # that generated the node. The method should yield to the given block which
+  # then calls through to visit each of the fields on the node.
+  #
+  # == text(name, value)
+  #
+  # This accepts the name of the field being visited as well as a string value
+  # representing the value of the field.
+  #
+  # == pairs(name, values)
+  #
+  # This accepts the name of the field being visited as well as a list of pairs
+  # that represent the value of the field. It is used only in a couple of
+  # circumstances, like when visiting the list of optional parameters defined on
+  # a method.
+  #
+  class FieldVisitor < BasicVisitor
+    visit_methods do
       def visit_aref(node)
         node(node, "aref") do
           field("collection", node.collection)
@@ -1017,14 +1016,14 @@ module SyntaxTree
       def visit___end__(node)
         visit_token(node, "__end__")
       end
+    end
 
-      private
+    private
 
-      def visit_token(node, type)
-        node(node, type) do
-          field("value", node.value)
-          comments(node)
-        end
+    def visit_token(node, type)
+      node(node, type) do
+        field("value", node.value)
+        comments(node)
       end
     end
   end

data/lib/syntax_tree/formatter.rb

@@ -138,7 +138,7 @@ module SyntaxTree
         # going to just print out the node as it was seen in the source.
         doc =
           if last_leading&.ignore?
-            range = source[node.location.start_char...node.location.end_char]
+            range = source[node.start_char...node.end_char]
             first = true
 
             range.each_line(chomp: true) do |line|

data/lib/syntax_tree/index.rb

@@ -257,74 +257,76 @@ module SyntaxTree
           @statements = nil
         end
 
-        def visit_class(node)
-          name = visit(node.constant).to_sym
-          location =
-            Location.new(node.location.start_line, node.location.start_column)
-
-          results << ClassDefinition.new(
-            nesting.dup,
-            name,
-            location,
-            comments_for(node)
-          )
-
-          nesting << name
-          super
-          nesting.pop
-        end
-
-        def visit_const_ref(node)
-          node.constant.value
-        end
+        visit_methods do
+          def visit_class(node)
+            name = visit(node.constant).to_sym
+            location =
+              Location.new(node.location.start_line, node.location.start_column)
 
-        def visit_def(node)
-          name = node.name.value.to_sym
-          location =
-            Location.new(node.location.start_line, node.location.start_column)
-
-          results << if node.target.nil?
-            MethodDefinition.new(
+            results << ClassDefinition.new(
               nesting.dup,
               name,
               location,
               comments_for(node)
             )
-          else
-            SingletonMethodDefinition.new(
+
+            nesting << name
+            super
+            nesting.pop
+          end
+
+          def visit_const_ref(node)
+            node.constant.value
+          end
+
+          def visit_def(node)
+            name = node.name.value.to_sym
+            location =
+              Location.new(node.location.start_line, node.location.start_column)
+
+            results << if node.target.nil?
+              MethodDefinition.new(
+                nesting.dup,
+                name,
+                location,
+                comments_for(node)
+              )
+            else
+              SingletonMethodDefinition.new(
+                nesting.dup,
+                name,
+                location,
+                comments_for(node)
+              )
+            end
+          end
+
+          def visit_module(node)
+            name = visit(node.constant).to_sym
+            location =
+              Location.new(node.location.start_line, node.location.start_column)
+
+            results << ModuleDefinition.new(
               nesting.dup,
               name,
               location,
               comments_for(node)
             )
-          end
-        end
-
-        def visit_module(node)
-          name = visit(node.constant).to_sym
-          location =
-            Location.new(node.location.start_line, node.location.start_column)
 
-          results << ModuleDefinition.new(
-            nesting.dup,
-            name,
-            location,
-            comments_for(node)
-          )
-
-          nesting << name
-          super
-          nesting.pop
-        end
+            nesting << name
+            super
+            nesting.pop
+          end
 
-        def visit_program(node)
-          super
-          results
-        end
+          def visit_program(node)
+            super
+            results
+          end
 
-        def visit_statements(node)
-          @statements = node
-          super
+          def visit_statements(node)
+            @statements = node
+            super
+          end
         end
 
         private

data/lib/syntax_tree/json_visitor.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SyntaxTree
+  # This visitor transforms the AST into a hash that contains only primitives
+  # that can be easily serialized into JSON.
+  class JSONVisitor < FieldVisitor
+    attr_reader :target
+
+    def initialize
+      @target = nil
+    end
+
+    private
+
+    def comments(node)
+      target[:comments] = visit_all(node.comments)
+    end
+
+    def field(name, value)
+      target[name] = value.is_a?(Node) ? visit(value) : value
+    end
+
+    def list(name, values)
+      target[name] = visit_all(values)
+    end
+
+    def node(node, type)
+      previous = @target
+      @target = { type: type, location: visit_location(node.location) }
+      yield
+      @target
+    ensure
+      @target = previous
+    end
+
+    def pairs(name, values)
+      target[name] = values.map { |(key, value)| [visit(key), visit(value)] }
+    end
+
+    def text(name, value)
+      target[name] = value
+    end
+
+    def visit_location(location)
+      [
+        location.start_line,
+        location.start_char,
+        location.end_line,
+        location.end_char
+      ]
+    end
+  end
+end

data/lib/syntax_tree/language_server.rb

@@ -2,10 +2,9 @@
 
 require "cgi"
 require "json"
+require "pp"
 require "uri"
 
-require_relative "language_server/inlay_hints"
-
 module SyntaxTree
   # Syntax Tree additionally ships with a language server conforming to the
   # language server protocol. It can be invoked through the CLI by running:
@@ -13,6 +12,162 @@ module SyntaxTree
   #     stree lsp
   #
   class LanguageServer
+    # 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
+      # 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 = []
+        @hints = []
+      end
+
+      def visit(node)
+        stack << node
+        result = super
+        stack.pop
+        result
+      end
+
+      visit_methods do
+        # Adds parentheses around assignments contained within the default
+        # values of parameters. For example,
+        #
+        #     def foo(a = b = c)
+        #     end
+        #
+        # becomes
+        #
+        #     def foo(a = ₍b = c₎)
+        #     end
+        #
+        def visit_assign(node)
+          parentheses(node.location) if stack[-2].is_a?(Params)
+          super
+        end
+
+        # Adds parentheses around binary expressions to make it clear which
+        # subexpression will be evaluated first. For example,
+        #
+        #     a + b * c
+        #
+        # becomes
+        #
+        #     a + ₍b * c₎
+        #
+        def visit_binary(node)
+          case stack[-2]
+          when Assign, OpAssign
+            parentheses(node.location)
+          when Binary
+            parentheses(node.location) if stack[-2].operator != node.operator
+          end
+
+          super
+        end
+
+        # Adds parentheses around ternary operators contained within certain
+        # expressions where it could be confusing which subexpression will get
+        # evaluated first. For example,
+        #
+        #     a ? b : c ? d : e
+        #
+        # becomes
+        #
+        #     a ? b : ₍c ? d : e₎
+        #
+        def visit_if_op(node)
+          case stack[-2]
+          when Assign, Binary, IfOp, OpAssign
+            parentheses(node.location)
+          end
+
+          super
+        end
+
+        # Adds the implicitly rescued StandardError into a bare rescue clause.
+        # For example,
+        #
+        #     begin
+        #     rescue
+        #     end
+        #
+        # becomes
+        #
+        #     begin
+        #     rescue StandardError
+        #     end
+        #
+        def visit_rescue(node)
+          if node.exception.nil?
+            hints << Hint.new(
+              line: node.location.start_line - 1,
+              character: node.location.start_column + "rescue".length,
+              label: " StandardError"
+            )
+          end
+
+          super
+        end
+
+        # Adds parentheses around unary statements using the - operator that are
+        # contained within Binary nodes. For example,
+        #
+        #     -a + b
+        #
+        # becomes
+        #
+        #     ₍-a₎ + b
+        #
+        def visit_unary(node)
+          if stack[-2].is_a?(Binary) && (node.operator == "-")
+            parentheses(node.location)
+          end
+
+          super
+        end
+      end
+
+      private
+
+      def parentheses(location)
+        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
+
     # This is a small module that effectively mirrors pattern matching. We're
     # using it so that we can support truffleruby without having to ignore the
     # language server.

data/lib/syntax_tree/match_visitor.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  # This visitor transforms the AST into a Ruby pattern matching expression that
+  # would match correctly against the AST.
+  class MatchVisitor < FieldVisitor
+    attr_reader :q
+
+    def initialize(q)
+      @q = q
+    end
+
+    def visit(node)
+      case node
+      when Node
+        super
+      when String
+        # pp will split up a string on newlines and concat them together using a
+        # "+" operator. This breaks the pattern matching expression. So instead
+        # we're going to check here for strings and manually put the entire
+        # value into the output buffer.
+        q.text(node.inspect)
+      else
+        node.pretty_print(q)
+      end
+    end
+
+    private
+
+    def comments(node)
+      return if node.comments.empty?
+
+      q.nest(0) do
+        q.text("comments: [")
+        q.indent do
+          q.breakable("")
+          q.seplist(node.comments) { |comment| visit(comment) }
+        end
+        q.breakable("")
+        q.text("]")
+      end
+    end
+
+    def field(name, value)
+      q.nest(0) do
+        q.text(name)
+        q.text(": ")
+        visit(value)
+      end
+    end
+
+    def list(name, values)
+      q.group do
+        q.text(name)
+        q.text(": [")
+        q.indent do
+          q.breakable("")
+          q.seplist(values) { |value| visit(value) }
+        end
+        q.breakable("")
+        q.text("]")
+      end
+    end
+
+    def node(node, _type)
+      items = []
+      q.with_target(items) { yield }
+
+      if items.empty?
+        q.text(node.class.name)
+        return
+      end
+
+      q.group do
+        q.text(node.class.name)
+        q.text("[")
+        q.indent do
+          q.breakable("")
+          q.seplist(items) { |item| q.target << item }
+        end
+        q.breakable("")
+        q.text("]")
+      end
+    end
+
+    def pairs(name, values)
+      q.group do
+        q.text(name)
+        q.text(": [")
+        q.indent do
+          q.breakable("")
+          q.seplist(values) do |(key, value)|
+            q.group do
+              q.text("[")
+              q.indent do
+                q.breakable("")
+                visit(key)
+                q.text(",")
+                q.breakable
+                visit(value || nil)
+              end
+              q.breakable("")
+              q.text("]")
+            end
+          end
+        end
+        q.breakable("")
+        q.text("]")
+      end
+    end
+
+    def text(name, value)
+      q.nest(0) do
+        q.text(name)
+        q.text(": ")
+        value.pretty_print(q)
+      end
+    end
+  end
+end