syntax_tree 5.3.0 → 6.0.0

data/lib/syntax_tree/language_server/inlay_hints.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  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
-
-      # 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
-
-      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
-  end
-end

data/lib/syntax_tree/visitor/environment.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  # The environment class is used to keep track of local variables and arguments
-  # inside a particular scope
-  class Environment
-    # This class tracks the occurrences of a local variable or argument
-    class Local
-      # [Symbol] The type of the local (e.g. :argument, :variable)
-      attr_reader :type
-
-      # [Array[Location]] The locations of all definitions and assignments of
-      # this local
-      attr_reader :definitions
-
-      # [Array[Location]] The locations of all usages of this local
-      attr_reader :usages
-
-      #   initialize: (Symbol type) -> void
-      def initialize(type)
-        @type = type
-        @definitions = []
-        @usages = []
-      end
-
-      #   add_definition: (Location location) -> void
-      def add_definition(location)
-        @definitions << location
-      end
-
-      #   add_usage: (Location location) -> void
-      def add_usage(location)
-        @usages << location
-      end
-    end
-
-    # [Array[Local]] The local variables and arguments defined in this
-    # environment
-    attr_reader :locals
-
-    # [Environment | nil] The parent environment
-    attr_reader :parent
-
-    #   initialize: (Environment | nil parent) -> void
-    def initialize(parent = nil)
-      @locals = {}
-      @parent = parent
-    end
-
-    # Adding a local definition will either insert a new entry in the locals
-    # hash or append a new definition location to an existing local. Notice that
-    # it's not possible to change the type of a local after it has been
-    # registered
-    #   add_local_definition: (Ident | Label identifier, Symbol type) -> void
-    def add_local_definition(identifier, type)
-      name = identifier.value.delete_suffix(":")
-
-      @locals[name] ||= Local.new(type)
-      @locals[name].add_definition(identifier.location)
-    end
-
-    # Adding a local usage will either insert a new entry in the locals
-    # hash or append a new usage location to an existing local. Notice that
-    # it's not possible to change the type of a local after it has been
-    # registered
-    #   add_local_usage: (Ident | Label identifier, Symbol type) -> void
-    def add_local_usage(identifier, type)
-      name = identifier.value.delete_suffix(":")
-
-      @locals[name] ||= Local.new(type)
-      @locals[name].add_usage(identifier.location)
-    end
-
-    # Try to find the local given its name in this environment or any of its
-    # parents
-    #   find_local: (String name) -> Local | nil
-    def find_local(name)
-      local = @locals[name]
-      return local unless local.nil?
-
-      @parent&.find_local(name)
-    end
-  end
-end

data/lib/syntax_tree/visitor/json_visitor.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  class Visitor
-    # 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
-end

data/lib/syntax_tree/visitor/match_visitor.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  class Visitor
-    # 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
-end

data/lib/syntax_tree/visitor/pretty_print_visitor.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  class Visitor
-    # This visitor pretty-prints the AST into an equivalent s-expression.
-    class PrettyPrintVisitor < FieldVisitor
-      attr_reader :q
-
-      def initialize(q)
-        @q = q
-      end
-
-      # This is here because we need to make sure the operator is cast to a
-      # string before we print it out.
-      def visit_binary(node)
-        node(node, "binary") do
-          field("left", node.left)
-          text("operator", node.operator.to_s)
-          field("right", node.right)
-          comments(node)
-        end
-      end
-
-      # This is here to make it a little nicer to look at labels since they
-      # typically have their : at the end of the value.
-      def visit_label(node)
-        node(node, "label") do
-          q.breakable
-          q.text(":")
-          q.text(node.value[0...-1])
-          comments(node)
-        end
-      end
-
-      private
-
-      def comments(node)
-        return if node.comments.empty?
-
-        q.breakable
-        q.group(2, "(", ")") do
-          q.seplist(node.comments) { |comment| q.pp(comment) }
-        end
-      end
-
-      def field(_name, value)
-        q.breakable
-        q.pp(value)
-      end
-
-      def list(_name, values)
-        q.breakable
-        q.group(2, "(", ")") { q.seplist(values) { |value| q.pp(value) } }
-      end
-
-      def node(_node, type)
-        q.group(2, "(", ")") do
-          q.text(type)
-          yield
-        end
-      end
-
-      def pairs(_name, values)
-        q.group(2, "(", ")") do
-          q.seplist(values) do |(key, value)|
-            q.pp(key)
-
-            if value
-              q.text("=")
-              q.group(2) do
-                q.breakable("")
-                q.pp(value)
-              end
-            end
-          end
-        end
-      end
-
-      def text(_name, value)
-        q.breakable
-        q.text(value)
-      end
-    end
-  end
-end

data/lib/syntax_tree/visitor/with_environment.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  # WithEnvironment is a module intended to be included in classes inheriting
-  # from Visitor. The module overrides a few visit methods to automatically keep
-  # track of local variables and arguments defined in the current environment.
-  # Example usage:
-  #   class MyVisitor < Visitor
-  #     include WithEnvironment
-  #
-  #     def visit_ident(node)
-  #       # Check if we're visiting an identifier for an argument, a local
-  #       variable or something else
-  #       local = current_environment.find_local(node)
-  #
-  #       if local.type == :argument
-  #         # handle identifiers for arguments
-  #       elsif local.type == :variable
-  #         # handle identifiers for variables
-  #       else
-  #         # handle other identifiers, such as method names
-  #       end
-  #   end
-  module WithEnvironment
-    def current_environment
-      @current_environment ||= Environment.new
-    end
-
-    def with_new_environment
-      previous_environment = @current_environment
-      @current_environment = Environment.new(previous_environment)
-      yield
-    ensure
-      @current_environment = previous_environment
-    end
-
-    # Visits for nodes that create new environments, such as classes, modules
-    # and method definitions
-    def visit_class(node)
-      with_new_environment { super }
-    end
-
-    def visit_module(node)
-      with_new_environment { super }
-    end
-
-    # When we find a method invocation with a block, only the code that happens
-    # inside of the block needs a fresh environment. The method invocation
-    # itself happens in the same environment
-    def visit_method_add_block(node)
-      visit(node.call)
-      with_new_environment { visit(node.block) }
-    end
-
-    def visit_def(node)
-      with_new_environment { super }
-    end
-
-    # Visit for keeping track of local arguments, such as method and block
-    # arguments
-    def visit_params(node)
-      add_argument_definitions(node.requireds)
-
-      node.posts.each do |param|
-        current_environment.add_local_definition(param, :argument)
-      end
-
-      node.keywords.each do |param|
-        current_environment.add_local_definition(param.first, :argument)
-      end
-
-      node.optionals.each do |param|
-        current_environment.add_local_definition(param.first, :argument)
-      end
-
-      super
-    end
-
-    def visit_rest_param(node)
-      name = node.name
-      current_environment.add_local_definition(name, :argument) if name
-
-      super
-    end
-
-    def visit_kwrest_param(node)
-      name = node.name
-      current_environment.add_local_definition(name, :argument) if name
-
-      super
-    end
-
-    def visit_blockarg(node)
-      name = node.name
-      current_environment.add_local_definition(name, :argument) if name
-
-      super
-    end
-
-    # Visit for keeping track of local variable definitions
-    def visit_var_field(node)
-      value = node.value
-
-      if value.is_a?(SyntaxTree::Ident)
-        current_environment.add_local_definition(value, :variable)
-      end
-
-      super
-    end
-
-    alias visit_pinned_var_ref visit_var_field
-
-    # Visits for keeping track of variable and argument usages
-    def visit_var_ref(node)
-      value = node.value
-
-      if value.is_a?(SyntaxTree::Ident)
-        definition = current_environment.find_local(value.value)
-
-        if definition
-          current_environment.add_local_usage(value, definition.type)
-        end
-      end
-
-      super
-    end
-
-    private
-
-    def add_argument_definitions(list)
-      list.each do |param|
-        if param.is_a?(SyntaxTree::MLHSParen)
-          add_argument_definitions(param.contents.parts)
-        else
-          current_environment.add_local_definition(param, :argument)
-        end
-      end
-    end
-  end
-end