syntax_tree 5.3.0 → 6.0.1

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

@@ -20,11 +20,12 @@ module SyntaxTree
 
     # This entry represents a class definition using the class keyword.
     class ClassDefinition
-      attr_reader :nesting, :name, :location, :comments
+      attr_reader :nesting, :name, :superclass, :location, :comments
 
-      def initialize(nesting, name, location, comments)
+      def initialize(nesting, name, superclass, location, comments)
         @nesting = nesting
         @name = name
+        @superclass = superclass
         @location = location
         @comments = comments
       end
@@ -176,30 +177,101 @@ module SyntaxTree
         Location.new(code_location[0], code_location[1])
       end
 
+      def find_constant_path(insns, index)
+        index -= 1 while insns[index].is_a?(Integer)
+        insn = insns[index]
+
+        if insn.is_a?(Array) && insn[0] == :opt_getconstant_path
+          # In this case we're on Ruby 3.2+ and we have an opt_getconstant_path
+          # instruction, so we already know all of the symbols in the nesting.
+          [index - 1, insn[1]]
+        elsif insn.is_a?(Symbol) && insn.match?(/\Alabel_\d+/)
+          # Otherwise, if we have a label then this is very likely the
+          # destination of an opt_getinlinecache instruction, in which case
+          # we'll walk backwards to grab up all of the constants.
+          names = []
+
+          index -= 1
+          until insns[index].is_a?(Array) &&
+                  insns[index][0] == :opt_getinlinecache
+            if insns[index].is_a?(Array) && insns[index][0] == :getconstant
+              names.unshift(insns[index][1])
+            end
+
+            index -= 1
+          end
+
+          [index - 1, names]
+        else
+          [index, []]
+        end
+      end
+
       def index_iseq(iseq, file_comments)
         results = []
         queue = [[iseq, []]]
 
         while (current_iseq, current_nesting = queue.shift)
-          current_iseq[13].each_with_index do |insn, index|
-            next unless insn.is_a?(Array)
+          line = current_iseq[8]
+          insns = current_iseq[13]
+
+          insns.each_with_index do |insn, index|
+            case insn
+            when Integer
+              line = insn
+              next
+            when Array
+              # continue on
+            else
+              # skip everything else
+              next
+            end
 
             case insn[0]
             when :defineclass
               _, name, class_iseq, flags = insn
+              next_nesting = current_nesting.dup
+
+              # This is the index we're going to search for the nested constant
+              # path within the declaration name.
+              constant_index = index - 2
+
+              # This is the superclass of the class being defined.
+              superclass = []
+
+              # If there is a superclass, then we're going to find it here and
+              # then update the constant_index as necessary.
+              if flags & VM_DEFINECLASS_FLAG_HAS_SUPERCLASS > 0
+                constant_index, superclass =
+                  find_constant_path(insns, index - 1)
+
+                if superclass.empty?
+                  raise NotImplementedError,
+                        "superclass with non constant path on line #{line}"
+                end
+              end
+
+              if (_, nesting = find_constant_path(insns, constant_index))
+                # If there is a constant path in the class name, then we need to
+                # handle that by updating the nesting.
+                next_nesting << (nesting << name)
+              else
+                # Otherwise we'll add the class name to the nesting.
+                next_nesting << [name]
+              end
 
               if flags == VM_DEFINECLASS_TYPE_SINGLETON_CLASS
                 # At the moment, we don't support singletons that aren't
                 # defined on self. We could, but it would require more
                 # emulation.
-                if current_iseq[13][index - 2] != [:putself]
+                if insns[index - 2] != [:putself]
                   raise NotImplementedError,
                         "singleton class with non-self receiver"
                 end
               elsif flags & VM_DEFINECLASS_TYPE_MODULE > 0
                 location = location_for(class_iseq)
                 results << ModuleDefinition.new(
-                  current_nesting,
+                  next_nesting,
                   name,
                   location,
                   EntryComments.new(file_comments, location)
@@ -207,14 +279,15 @@ module SyntaxTree
               else
                 location = location_for(class_iseq)
                 results << ClassDefinition.new(
-                  current_nesting,
+                  next_nesting,
                   name,
+                  superclass,
                   location,
                   EntryComments.new(file_comments, location)
                 )
               end
 
-              queue << [class_iseq, current_nesting + [name]]
+              queue << [class_iseq, next_nesting]
             when :definemethod
               location = location_for(insn[2])
               results << MethodDefinition.new(
@@ -257,74 +330,100 @@ 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)
+        visit_methods do
+          def visit_class(node)
+            names = visit(node.constant)
+            nesting << names
 
-          results << ClassDefinition.new(
-            nesting.dup,
-            name,
-            location,
-            comments_for(node)
-          )
+            location =
+              Location.new(node.location.start_line, node.location.start_column)
 
-          nesting << name
-          super
-          nesting.pop
-        end
+            superclass =
+              if node.superclass
+                visited = visit(node.superclass)
 
-        def visit_const_ref(node)
-          node.constant.value
-        end
+                if visited == [[]]
+                  raise NotImplementedError, "superclass with non constant path"
+                end
 
-        def visit_def(node)
-          name = node.name.value.to_sym
-          location =
-            Location.new(node.location.start_line, node.location.start_column)
+                visited
+              else
+                []
+              end
 
-          results << if node.target.nil?
-            MethodDefinition.new(
+            results << ClassDefinition.new(
               nesting.dup,
-              name,
+              names.last,
+              superclass,
               location,
               comments_for(node)
             )
-          else
-            SingletonMethodDefinition.new(
+
+            super
+            nesting.pop
+          end
+
+          def visit_const_ref(node)
+            [node.constant.value.to_sym]
+          end
+
+          def visit_const_path_ref(node)
+            visit(node.parent) << node.constant.value.to_sym
+          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)
+            names = visit(node.constant)
+            nesting << names
+
+            location =
+              Location.new(node.location.start_line, node.location.start_column)
+
+            results << ModuleDefinition.new(
               nesting.dup,
-              name,
+              names.last,
               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)
-          )
+            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
+          end
 
-        def visit_statements(node)
-          @statements = node
-          super
+          def visit_var_ref(node)
+            [node.value.value.to_sym]
+          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.