Rename implicits to inlay hints

Author: kddnewton

CHANGELOG.md

@@ -12,6 +12,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - Changed `SyntaxTree` from being a class to being a module. The parser functionality is moved into `SyntaxTree::Parser`.
 - There is now a parent class for all of the nodes named `SyntaxTree::Node`.
+- The `Implicits` class has been renamed to `InlayHints` to match the new LSP spec.
+
+### Removed
+
+- The disassembly code action has been removed to limit the scope of this project overall.
 
 ## [1.2.0] - 2022-01-09
 

lib/syntax_tree/code_actions.rb

@@ -4,8 +4,7 @@
 require "json"
 require "uri"
 
-require_relative "code_actions"
-require_relative "implicits"
+require_relative "language_server/inlay_hints"
 
 module SyntaxTree
   class LanguageServer
@@ -35,8 +34,6 @@ def run
         in { method: "shutdown" }
           store.clear
           return
-        in { method: "textDocument/codeAction", id:, params: { textDocument: { uri: }, range: { start: { line: } } } }
-          write(id: id, result: code_actions(store[uri], line + 1))
         in { method: "textDocument/didChange", params: { textDocument: { uri: }, contentChanges: [{ text: }, *] } }
           store[uri] = text
         in { method: "textDocument/didOpen", params: { textDocument: { uri:, text: } } }
@@ -45,10 +42,8 @@ def run
           store.delete(uri)
         in { method: "textDocument/formatting", id:, params: { textDocument: { uri: } } }
           write(id: id, result: [format(store[uri])])
-        in { method: "syntaxTree/disasm", id:, params: { textDocument: { uri:, query: { line:, name: } } } }
-          write(id: id, result: disasm(store[uri], line.to_i, name))
-        in { method: "syntaxTree/implicits", id:, params: { textDocument: { uri: } } }
-          write(id: id, result: implicits(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: } } }
           output = []
           PP.pp(SyntaxTree.parse(store[uri]), output)
@@ -65,43 +60,11 @@ def run
 
     def capabilities
       {
-        codeActionProvider: { codeActionsKinds: ["disasm"] },
         documentFormattingProvider: true,
         textDocumentSync: { change: 1, openClose: true }
       }
     end
 
-    def code_actions(source, line)
-      actions = CodeActions.find(SyntaxTree.parse(source), line).actions
-      log("Found #{actions.length} actions on line #{line}")
-
-      actions.map(&:as_json)
-    end
-
-    def disasm(source, line, name)
-      actions = CodeActions.find(SyntaxTree.parse(source), line).actions
-      log("Disassembling #{name.inspect} on line #{line.inspect}")
-
-      matched = actions.detect { |action| action.is_a?(CodeActions::DisasmAction) && action.node.name.value == name }
-      return "Unable to find method: #{name}" unless matched
-
-      # First, get an instruction sequence that encompasses the method that
-      # we're going to disassemble. It will include the method declaration,
-      # which will be the top instruction sequence.
-      location = matched.node.location
-      iseq = RubyVM::InstructionSequence.new(source[location.start_char...location.end_char])
-
-      # Next, get the first child. We do this because the parent instruction
-      # sequence is the method declaration, whereas the first child is the body
-      # of the method, which is what we're interested in.
-      method = nil
-      iseq.each_child { |child| method = child }
-
-      # Finally, return the disassembly as a string to the server, which will
-      # serialize it to JSON and return it back to the client.
-      method.disasm
-    end
-
     def format(source)
       {
         range: {
@@ -116,15 +79,15 @@ def log(message)
       write(method: "window/logMessage", params: { type: 4, message: message })
     end
 
-    def implicits(source)
-      implicits = Implicits.find(SyntaxTree.parse(source))
+    def inlay_hints(source)
+      inlay_hints = InlayHints.find(SyntaxTree.parse(source))
       serialize = ->(position, text) { { position: position, text: text } }
 
       {
-        before: implicits.before.map(&serialize),
-        after: implicits.after.map(&serialize)
+        before: inlay_hints.before.map(&serialize),
+        after: inlay_hints.after.map(&serialize)
       }
-    rescue ParseError
+    rescue Parser::ParseError
     end
 
     def write(value)

lib/syntax_tree/implicits.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  class LanguageServer
+    class InlayHints
+      attr_reader :before, :after
+
+      def initialize
+        @before = Hash.new { |hash, key| hash[key] = +"" }
+        @after = Hash.new { |hash, key| hash[key] = +"" }
+      end
+
+      # Adds the implicitly rescued StandardError into a bare rescue clause. For
+      # example,
+      #
+      #     begin
+      #     rescue
+      #     end
+      #
+      # becomes
+      #
+      #     begin
+      #     rescue StandardError
+      #     end
+      #
+      def bare_rescue(location)
+        after[location.start_char + "rescue".length] << " StandardError"
+      end
+
+      # Adds the implicitly referenced value (local variable or method call)
+      # that is added into a hash when the value of a key-value pair is omitted.
+      # For example,
+      #
+      #     { value: }
+      #
+      # becomes
+      #
+      #     { value: value }
+      #
+      def missing_hash_value(key, location)
+        after[location.end_char] << " #{key}"
+      end
+
+      # Adds implicit parentheses around certain expressions to make it clear
+      # which subexpression will be evaluated first. For example,
+      #
+      #     a + b * c
+      #
+      # becomes
+      #
+      #     a + ₍b * c₎
+      #
+      def precedence_parentheses(location)
+        before[location.start_char] << "₍"
+        after[location.end_char] << "₎"
+      end
+
+      def self.find(program)
+        inlay_hints = new
+        queue = [[nil, program]]
+
+        until queue.empty?
+          parent_node, child_node = queue.shift
+
+          child_node.child_nodes.each do |grand_child_node|
+            queue << [child_node, grand_child_node] if grand_child_node
+          end
+
+          case [parent_node, child_node]
+          in _, Rescue[exception: nil, location:]
+            inlay_hints.bare_rescue(location)
+          in _, Assoc[key: Label[value: key], value: nil, location:]
+            inlay_hints.missing_hash_value(key[0...-1], location)
+          in Assign | Binary | IfOp | OpAssign, IfOp[location:]
+            inlay_hints.precedence_parentheses(location)
+          in Assign | OpAssign, Binary[location:]
+            inlay_hints.precedence_parentheses(location)
+          in Binary[operator: parent_oper], Binary[operator: child_oper, location:] if parent_oper != child_oper
+            inlay_hints.precedence_parentheses(location)
+          in Binary, Unary[operator: "-", location:]
+            inlay_hints.precedence_parentheses(location)
+          in Params, Assign[location:]
+            inlay_hints.precedence_parentheses(location)
+          else
+            # do nothing
+          end
+        end
+
+        inlay_hints
+      end
+    end
+  end
+end