syntax_tree 2.2.0 → 2.4.0

data/lib/syntax_tree/node.rb

@@ -3,9 +3,21 @@
 module SyntaxTree
   # Represents the location of a node in the tree from the source code.
   class Location
-    attr_reader :start_line, :start_char, :start_column, :end_line, :end_char, :end_column
+    attr_reader :start_line,
+                :start_char,
+                :start_column,
+                :end_line,
+                :end_char,
+                :end_column
 
-    def initialize(start_line:, start_char:, start_column:, end_line:, end_char:, end_column:)
+    def initialize(
+      start_line:,
+      start_char:,
+      start_column:,
+      end_line:,
+      end_char:,
+      end_column:
+    )
       @start_line = start_line
       @start_char = start_char
       @start_column = start_column
@@ -39,7 +51,7 @@ module SyntaxTree
       [start_line, start_char, start_column, end_line, end_char, end_column]
     end
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         start_line: start_line,
         start_char: start_char,
@@ -62,7 +74,14 @@ module SyntaxTree
     end
 
     def self.fixed(line:, char:, column:)
-      new(start_line: line, start_char: char, start_column: column, end_line: line, end_char: char, end_column: column)
+      new(
+        start_line: line,
+        start_char: char,
+        start_column: column,
+        end_line: line,
+        end_char: char,
+        end_column: column
+      )
     end
   end
 
@@ -102,6 +121,10 @@ module SyntaxTree
       visitor = Visitor::JSONVisitor.new
       visitor.visit(self).to_json(*opts)
     end
+
+    def construct_keys
+      PP.format(+"") { |q| Visitor::MatchVisitor.new(q).visit(self) }
+    end
   end
 
   # BEGINBlock represents the use of the +BEGIN+ keyword, which hooks into the
@@ -140,7 +163,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         lbrace: lbrace,
         statements: statements,
@@ -192,7 +215,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -243,7 +266,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         lbrace: lbrace,
         statements: statements,
@@ -298,7 +321,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -323,6 +346,8 @@ module SyntaxTree
   # symbols (note that this includes dynamic symbols like
   # :"left-#{middle}-right").
   class Alias < Node
+    # Formats an argument to the alias keyword. For symbol literals it uses the
+    # value of the symbol directly to look like bare words.
     class AliasArgumentFormatter
       # [DynaSymbol | SymbolLiteral] the argument being passed to alias
       attr_reader :argument
@@ -374,7 +399,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { left: left, right: right, location: location, comments: comments }
     end
 
@@ -435,7 +460,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         collection: collection,
         index: index,
@@ -496,7 +521,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         collection: collection,
         index: index,
@@ -558,7 +583,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { arguments: arguments, location: location, comments: comments }
     end
 
@@ -606,7 +631,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parts: parts, location: location, comments: comments }
     end
 
@@ -642,7 +667,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -679,7 +704,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -729,7 +754,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -745,6 +770,7 @@ module SyntaxTree
   #     [one, two, three]
   #
   class ArrayLiteral < Node
+    # Formats an array of multiple simple string literals into the %w syntax.
     class QWordsFormatter
       # [Args] the contents of the array
       attr_reader :contents
@@ -761,7 +787,7 @@ module SyntaxTree
               if part.is_a?(StringLiteral)
                 q.format(part.parts.first)
               else
-                q.text(part.value[1..-1])
+                q.text(part.value[1..])
               end
             end
           end
@@ -770,6 +796,7 @@ module SyntaxTree
       end
     end
 
+    # Formats an array of multiple simple symbol literals into the %i syntax.
     class QSymbolsFormatter
       # [Args] the contents of the array
       attr_reader :contents
@@ -791,6 +818,28 @@ module SyntaxTree
       end
     end
 
+    # Formats an array that contains only a list of variable references. To make
+    # things simpler, if there are a bunch, we format them all using the "fill"
+    # algorithm as opposed to breaking them into a ton of lines. For example,
+    #
+    #     [foo, bar, baz]
+    #
+    # instead of becoming:
+    #
+    #     [
+    #       foo,
+    #       bar,
+    #       baz
+    #     ]
+    #
+    # would instead become:
+    #
+    #     [
+    #       foo, bar,
+    #       baz
+    #     ]
+    #
+    # provided the line length was hit between `bar` and `baz`.
     class VarRefsFormatter
       # [Args] the contents of the array
       attr_reader :contents
@@ -816,6 +865,32 @@ module SyntaxTree
       end
     end
 
+    # This is a special formatter used if the array literal contains no values
+    # but _does_ contain comments. In this case we do some special formatting to
+    # make sure the comments gets indented properly.
+    class EmptyWithCommentsFormatter
+      # [LBracket] the opening bracket
+      attr_reader :lbracket
+
+      def initialize(lbracket)
+        @lbracket = lbracket
+      end
+
+      def format(q)
+        q.group do
+          q.text("[")
+          q.indent do
+            lbracket.comments.each do |comment|
+              q.breakable(force: true)
+              comment.format(q)
+            end
+          end
+          q.breakable(force: true)
+          q.text("]")
+        end
+      end
+    end
+
     # [LBracket] the bracket that opens this array
     attr_reader :lbracket
 
@@ -842,7 +917,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         lbracket: lbracket,
         contents: contents,
@@ -867,6 +942,11 @@ module SyntaxTree
         return
       end
 
+      if empty_with_comments?
+        EmptyWithCommentsFormatter.new(lbracket).format(q)
+        return
+      end
+
       q.group do
         q.format(lbracket)
 
@@ -919,6 +999,13 @@ module SyntaxTree
             q.maxwidth * 2
         )
     end
+
+    # If we have an empty array that contains only comments, then we're going
+    # to do some special printing to ensure they get indented correctly.
+    def empty_with_comments?
+      contents.nil? && lbracket.comments.any? &&
+        lbracket.comments.none?(&:inline?)
+    end
   end
 
   # AryPtn represents matching against an array pattern using the Ruby 2.7+
@@ -939,6 +1026,7 @@ module SyntaxTree
   # and an optional array of positional matches that occur after the splat.
   # All of the in clauses above would create an AryPtn node.
   class AryPtn < Node
+    # Formats the optional splat of an array pattern.
     class RestFormatter
       # [VarField] the identifier that represents the remaining positionals
       attr_reader :value
@@ -1001,7 +1089,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         constant: constant,
         requireds: requireds,
@@ -1033,6 +1121,8 @@ module SyntaxTree
         q.text("[")
         q.seplist(parts) { |part| q.format(part) }
         q.text("]")
+      elsif parts.empty?
+        q.text("[]")
       else
         q.group { q.seplist(parts) { |part| q.format(part) } }
       end
@@ -1042,17 +1132,17 @@ module SyntaxTree
   # Determins if the following value should be indented or not.
   module AssignFormatting
     def self.skip_indent?(value)
-      (value.is_a?(Call) && skip_indent?(value.receiver)) ||
-        [
-          ArrayLiteral,
-          HashLiteral,
-          Heredoc,
-          Lambda,
-          QSymbols,
-          QWords,
-          Symbols,
-          Words
-        ].include?(value.class)
+      case value
+      in ArrayLiteral | HashLiteral | Heredoc | Lambda | QSymbols | QWords |
+           Symbols | Words
+        true
+      in Call[receiver:]
+        skip_indent?(receiver)
+      in DynaSymbol[quote:]
+        quote.start_with?("%s")
+      else
+        false
+      end
     end
   end
 
@@ -1090,7 +1180,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { target: target, value: value, location: location, comments: comments }
     end
 
@@ -1152,12 +1242,12 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { key: key, value: value, location: location, comments: comments }
     end
 
     def format(q)
-      if value&.is_a?(HashLiteral)
+      if value.is_a?(HashLiteral)
         format_contents(q)
       else
         q.group { format_contents(q) }
@@ -1210,7 +1300,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -1248,7 +1338,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -1283,7 +1373,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -1296,21 +1386,28 @@ module SyntaxTree
   # hash or bare hash. It first determines if every key in the hash can use
   # labels. If it can, it uses labels. Otherwise it uses hash rockets.
   module HashKeyFormatter
+    # Formats the keys of a hash literal using labels.
     class Labels
+      LABEL = /^[@$_A-Za-z]([_A-Za-z0-9]*)?([!_=?A-Za-z0-9])?$/
+
       def format_key(q, key)
         case key
-        when Label
+        in Label
           q.format(key)
-        when SymbolLiteral
+        in SymbolLiteral
           q.format(key.value)
           q.text(":")
-        when DynaSymbol
+        in DynaSymbol[parts: [TStringContent[value: LABEL] => part]]
+          q.format(part)
+          q.text(":")
+        in DynaSymbol
           q.format(key)
           q.text(":")
         end
       end
     end
 
+    # Formats the keys of a hash literal using hash rockets.
     class Rockets
       def format_key(q, key)
         case key
@@ -1384,7 +1481,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { assocs: assocs, location: location, comments: comments }
     end
 
@@ -1426,7 +1523,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { bodystmt: bodystmt, location: location, comments: comments }
     end
 
@@ -1474,7 +1571,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { statement: statement, location: location, comments: comments }
     end
 
@@ -1534,7 +1631,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         left: left,
         operator: operator,
@@ -1552,12 +1649,12 @@ module SyntaxTree
         q.text(" ") unless power
 
         if operator == :<<
-          q.text(operator)
+          q.text(operator.to_s)
           q.text(" ")
           q.format(right)
         else
           q.group do
-            q.text(operator)
+            q.text(operator.to_s)
 
             q.indent do
               q.breakable(power ? "" : " ")
@@ -1649,7 +1746,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { params: params, locals: locals, location: location, comments: comments }
     end
 
@@ -1693,7 +1790,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { name: name, location: location, comments: comments }
     end
 
@@ -1789,7 +1886,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         statements: statements,
         rescue_clause: rescue_clause,
@@ -1835,6 +1932,7 @@ module SyntaxTree
 
   # Responsible for formatting either a BraceBlock or a DoBlock.
   class BlockFormatter
+    # Formats the opening brace or keyword of a block.
     class BlockOpenFormatter
       # [String] the actual output that should be printed
       attr_reader :text
@@ -1900,9 +1998,9 @@ module SyntaxTree
       end
 
       q.group do
-        q.if_break { format_break(q, break_opening, break_closing) }.if_flat do
-          format_flat(q, flat_opening, flat_closing)
-        end
+        q
+          .if_break { format_break(q, break_opening, break_closing) }
+          .if_flat { format_flat(q, flat_opening, flat_closing) }
       end
     end
 
@@ -2027,7 +2125,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         lbrace: lbrace,
         block_var: block_var,
@@ -2042,12 +2140,12 @@ module SyntaxTree
     end
   end
 
-  # Formats either a Break or Next node.
+  # Formats either a Break, Next, or Return node.
   class FlowControlFormatter
     # [String] the keyword to print
     attr_reader :keyword
 
-    # [Break | Next] the node being formatted
+    # [Break | Next | Return] the node being formatted
     attr_reader :node
 
     def initialize(keyword, node)
@@ -2056,32 +2154,123 @@ module SyntaxTree
     end
 
     def format(q)
-      arguments = node.arguments
-
       q.group do
         q.text(keyword)
 
-        if arguments.parts.any?
-          if arguments.parts.length == 1
-            part = arguments.parts.first
-
-            if part.is_a?(Paren)
-              q.format(arguments)
-            elsif part.is_a?(ArrayLiteral)
-              q.text(" ")
-              q.format(arguments)
-            else
-              format_arguments(q, "(", ")")
-            end
-          else
-            format_arguments(q, " [", "]")
-          end
+        case node.arguments.parts
+        in []
+          # Here there are no arguments at all, so we're not going to print
+          # anything. This would be like if we had:
+          #
+          #     break
+          #
+        in [Paren[
+             contents: {
+               body: [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
+             }
+           ]]
+          # Here we have a single argument that is a set of parentheses wrapping
+          # an array literal that has at least 2 elements. We're going to print
+          # the contents of the array directly. This would be like if we had:
+          #
+          #     break([1, 2, 3])
+          #
+          # which we will print as:
+          #
+          #     break 1, 2, 3
+          #
+          q.text(" ")
+          format_array_contents(q, array)
+        in [Paren[contents: { body: [ArrayLiteral => statement] }]]
+          # Here we have a single argument that is a set of parentheses wrapping
+          # an array literal that has 0 or 1 elements. We're going to skip the
+          # parentheses but print the array itself. This would be like if we
+          # had:
+          #
+          #     break([1])
+          #
+          # which we will print as:
+          #
+          #     break [1]
+          #
+          q.text(" ")
+          q.format(statement)
+        in [Paren[contents: { body: [statement] }]] if skip_parens?(statement)
+          # Here we have a single argument that is a set of parentheses that
+          # themselves contain a single statement. That statement is a simple
+          # value that we can skip the parentheses for. This would be like if we
+          # had:
+          #
+          #     break(1)
+          #
+          # which we will print as:
+          #
+          #     break 1
+          #
+          q.text(" ")
+          q.format(statement)
+        in [Paren => part]
+          # Here we have a single argument that is a set of parentheses. We're
+          # going to print the parentheses themselves as if they were the set of
+          # arguments. This would be like if we had:
+          #
+          #     break(foo.bar)
+          #
+          q.format(part)
+        in [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
+          # Here there is a single argument that is an array literal with at
+          # least two elements. We skip directly into the array literal's
+          # elements in order to print the contents. This would be like if we
+          # had:
+          #
+          #     break [1, 2, 3]
+          #
+          # which we will print as:
+          #
+          #     break 1, 2, 3
+          #
+          q.text(" ")
+          format_array_contents(q, array)
+        in [ArrayLiteral => part]
+          # Here there is a single argument that is an array literal with 0 or 1
+          # elements. In this case we're going to print the array as it is
+          # because skipping the brackets would change the remaining. This would
+          # be like if we had:
+          #
+          #     break []
+          #     break [1]
+          #
+          q.text(" ")
+          q.format(part)
+        in [_]
+          # Here there is a single argument that hasn't matched one of our
+          # previous cases. We're going to print the argument as it is. This
+          # would be like if we had:
+          #
+          #     break foo
+          #
+          format_arguments(q, "(", ")")
+        else
+          # If there are multiple arguments, format them all. If the line is
+          # going to break into multiple, then use brackets to start and end the
+          # expression.
+          format_arguments(q, " [", "]")
         end
       end
     end
 
     private
 
+    def format_array_contents(q, array)
+      q.if_break { q.text("[") }
+      q.indent do
+        q.breakable("")
+        q.format(array.contents)
+      end
+      q.breakable("")
+      q.if_break { q.text("]") }
+    end
+
     def format_arguments(q, opening, closing)
       q.if_break { q.text(opening) }
       q.indent do
@@ -2091,6 +2280,17 @@ module SyntaxTree
       q.breakable("")
       q.if_break { q.text(closing) }
     end
+
+    def skip_parens?(node)
+      case node
+      in FloatLiteral | Imaginary | Int | RationalLiteral
+        true
+      in VarRef[value: Const | CVar | GVar | IVar | Kw]
+        true
+      else
+        false
+      end
+    end
   end
 
   # Break represents using the +break+ keyword.
@@ -2124,7 +2324,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { arguments: arguments, location: location, comments: comments }
     end
 
@@ -2156,6 +2356,211 @@ module SyntaxTree
     end
   end
 
+  # This is probably the most complicated formatter in this file. It's
+  # responsible for formatting chains of method calls, with or without arguments
+  # or blocks. In general, we want to go from something like
+  #
+  #     foo.bar.baz
+  #
+  # to
+  #
+  #     foo
+  #       .bar
+  #       .baz
+  #
+  # Of course there are a lot of caveats to that, including trailing operators
+  # when necessary, where comments are places, how blocks are aligned, etc.
+  class CallChainFormatter
+    # [Call | MethodAddBlock] the top of the call chain
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+
+    def format(q)
+      children = [node]
+      threshold = 3
+
+      # First, walk down the chain until we get to the point where we're not
+      # longer at a chainable node.
+      loop do
+        case children.last
+        in Call[receiver: Call]
+          children << children.last.receiver
+        in Call[receiver: MethodAddBlock[call: Call]]
+          children << children.last.receiver
+        in MethodAddBlock[call: Call]
+          children << children.last.call
+        else
+          break
+        end
+      end
+
+      # Here, we have very specialized behavior where if we're within a sig
+      # block, then we're going to assume we're creating a Sorbet type
+      # signature. In that case, we really want the threshold to be lowered so
+      # that we create method chains off of any two method calls within the
+      # block. For more details, see
+      # https://github.com/prettier/plugin-ruby/issues/863.
+      parents = q.parents.take(4)
+      if (parent = parents[2])
+        # If we're at a do_block, then we want to go one more level up. This is
+        # because do blocks have BodyStmt nodes instead of just Statements
+        # nodes.
+        parent = parents[3] if parent.is_a?(DoBlock)
+
+        case parent
+        in MethodAddBlock[call: FCall[value: { value: "sig" }]]
+          threshold = 2
+        else
+        end
+      end
+
+      if children.length >= threshold
+        q.group do
+          q
+            .if_break { format_chain(q, children) }
+            .if_flat { node.format_contents(q) }
+        end
+      else
+        node.format_contents(q)
+      end
+    end
+
+    def format_chain(q, children)
+      # We're going to have some specialized behavior for if it's an entire
+      # chain of calls without arguments except for the last one. This is common
+      # enough in Ruby source code that it's worth the extra complexity here.
+      empty_except_last =
+        children
+          .drop(1)
+          .all? { |child| child.is_a?(Call) && child.arguments.nil? }
+
+      # Here, we're going to add all of the children onto the stack of the
+      # formatter so it's as if we had descending normally into them. This is
+      # necessary so they can check their parents as normal.
+      q.stack.concat(children)
+      q.format(children.last.receiver)
+
+      q.group do
+        if attach_directly?(children.last)
+          format_child(q, children.pop)
+          q.stack.pop
+        end
+
+        q.indent do
+          # We track another variable that checks if you need to move the
+          # operator to the previous line in case there are trailing comments
+          # and a trailing operator.
+          skip_operator = false
+
+          while (child = children.pop)
+            case child
+            in Call[
+                 receiver: Call[message: { value: "where" }],
+                 message: { value: "not" }
+               ]
+              # This is very specialized behavior wherein we group
+              # .where.not calls together because it looks better. For more
+              # information, see
+              # https://github.com/prettier/plugin-ruby/issues/862.
+            in Call
+              # If we're at a Call node and not a MethodAddBlock node in the
+              # chain then we're going to add a newline so it indents properly.
+              q.breakable("")
+            else
+            end
+
+            format_child(
+              q,
+              child,
+              skip_comments: children.empty?,
+              skip_operator: skip_operator,
+              skip_attached: empty_except_last && children.empty?
+            )
+
+            # If the parent call node has a comment on the message then we need
+            # to print the operator trailing in order to keep it working.
+            case children.last
+            in Call[message: { comments: [_, *] }, operator:]
+              q.format(CallOperatorFormatter.new(operator))
+              skip_operator = true
+            else
+              skip_operator = false
+            end
+
+            # Pop off the formatter's stack so that it aligns with what would
+            # have happened if we had been formatting normally.
+            q.stack.pop
+          end
+        end
+      end
+
+      if empty_except_last
+        case node
+        in Call
+          node.format_arguments(q)
+        in MethodAddBlock[block:]
+          q.format(block)
+        end
+      end
+    end
+
+    def self.chained?(node)
+      case node
+      in Call | MethodAddBlock[call: Call]
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    # For certain nodes, we want to attach directly to the end and don't
+    # want to indent the first call. So we'll pop off the first children and
+    # format it separately here.
+    def attach_directly?(node)
+      [ArrayLiteral, HashLiteral, Heredoc, If, Unless, XStringLiteral].include?(
+        node.receiver.class
+      )
+    end
+
+    def format_child(
+      q,
+      child,
+      skip_comments: false,
+      skip_operator: false,
+      skip_attached: false
+    )
+      # First, format the actual contents of the child.
+      case child
+      in Call
+        q.group do
+          unless skip_operator
+            q.format(CallOperatorFormatter.new(child.operator))
+          end
+          q.format(child.message) if child.message != :call
+          child.format_arguments(q) unless skip_attached
+        end
+      in MethodAddBlock
+        q.format(child.block) unless skip_attached
+      end
+
+      # If there are any comments on this node then we need to explicitly print
+      # them out here since we're bypassing the normal comment printing.
+      if child.comments.any? && !skip_comments
+        child.comments.each do |comment|
+          comment.inline? ? q.text(" ") : q.breakable
+          comment.format(q)
+        end
+
+        q.break_parent
+      end
+    end
+  end
+
   # Call represents a method call.
   #
   #     receiver.message
@@ -2207,7 +2612,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         receiver: receiver,
         operator: operator,
@@ -2219,6 +2624,34 @@ module SyntaxTree
     end
 
     def format(q)
+      # If we're at the top of a call chain, then we're going to do some
+      # specialized printing in case we can print it nicely. We _only_ do this
+      # at the top of the chain to avoid weird recursion issues.
+      if !CallChainFormatter.chained?(q.parent) &&
+           CallChainFormatter.chained?(receiver)
+        q.group do
+          q
+            .if_break { CallChainFormatter.new(self).format(q) }
+            .if_flat { format_contents(q) }
+        end
+      else
+        format_contents(q)
+      end
+    end
+
+    def format_arguments(q)
+      case arguments
+      in ArgParen
+        q.format(arguments)
+      in Args
+        q.text(" ")
+        q.format(arguments)
+      else
+        # Do nothing if there are no arguments.
+      end
+    end
+
+    def format_contents(q)
       call_operator = CallOperatorFormatter.new(operator)
 
       q.group do
@@ -2241,7 +2674,7 @@ module SyntaxTree
             q.format(message) if message != :call
           end
 
-          q.format(arguments) if arguments
+          format_arguments(q)
         end
       end
     end
@@ -2289,7 +2722,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         keyword: keyword,
         value: value,
@@ -2354,7 +2787,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         value: value,
         operator: operator,
@@ -2443,7 +2876,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         constant: constant,
         superclass: superclass,
@@ -2507,8 +2940,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -2546,7 +2979,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         message: message,
         arguments: arguments,
@@ -2558,26 +2991,25 @@ module SyntaxTree
     def format(q)
       q.group do
         q.format(message)
-        q.text(" ")
-
-        if align?(self)
-          q.nest(message.value.length + 1) { q.format(arguments) }
-        else
-          q.format(arguments)
-        end
+        align(q, self) { q.format(arguments) }
       end
     end
 
     private
 
-    def align?(node)
+    def align(q, node, &block)
       case node.arguments
       in Args[parts: [Def | Defs | DefEndless]]
-        false
+        q.text(" ")
+        yield
+      in Args[parts: [IfOp]]
+        q.if_flat { q.text(" ") }
+        yield
       in Args[parts: [Command => command]]
-        align?(command)
+        align(q, command, &block)
       else
-        true
+        q.text(" ")
+        q.nest(message.value.length + 1) { yield }
       end
     end
   end
@@ -2629,7 +3061,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         receiver: receiver,
         operator: operator,
@@ -2649,9 +3081,15 @@ module SyntaxTree
             q.format(message)
           end
 
-        if arguments
+        case arguments
+        in Args[parts: [IfOp]]
+          q.if_flat { q.text(" ") }
+          q.format(arguments)
+        in Args
           q.text(" ")
           q.nest(argument_alignment(q, doc)) { q.format(arguments) }
+        else
+          # If there are no arguments, print nothing.
         end
       end
     end
@@ -2745,7 +3183,7 @@ module SyntaxTree
     end
 
     def ignore?
-      value[1..-1].strip == "stree-ignore"
+      value[1..].strip == "stree-ignore"
     end
 
     def comments
@@ -2762,7 +3200,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, inline: inline, location: location }
     end
 
@@ -2808,7 +3246,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -2850,7 +3288,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         parent: parent,
         constant: constant,
@@ -2897,7 +3335,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         parent: parent,
         constant: constant,
@@ -2942,7 +3380,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { constant: constant, location: location, comments: comments }
     end
 
@@ -2978,7 +3416,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -3022,7 +3460,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         name: name,
         params: params,
@@ -3037,7 +3475,10 @@ module SyntaxTree
         q.group do
           q.text("def ")
           q.format(name)
-          q.format(params) if !params.is_a?(Params) || !params.empty?
+
+          if !params.is_a?(Params) || !params.empty? || params.comments.any?
+            q.format(params)
+          end
         end
 
         unless bodystmt.empty?
@@ -3104,7 +3545,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         target: target,
         operator: operator,
@@ -3172,7 +3613,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -3238,7 +3679,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         target: target,
         operator: operator,
@@ -3257,7 +3698,10 @@ module SyntaxTree
           q.format(target)
           q.format(CallOperatorFormatter.new(operator), stackable: false)
           q.format(name)
-          q.format(params) if !params.is_a?(Params) || !params.empty?
+
+          if !params.is_a?(Params) || !params.empty? || params.comments.any?
+            q.format(params)
+          end
         end
 
         unless bodystmt.empty?
@@ -3310,7 +3754,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         keyword: keyword,
         block_var: block_var,
@@ -3390,7 +3834,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { left: left, right: right, location: location, comments: comments }
     end
 
@@ -3438,7 +3882,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { left: left, right: right, location: location, comments: comments }
     end
 
@@ -3460,7 +3904,7 @@ module SyntaxTree
     # quotes, then single quotes would deactivate it.)
     def self.locked?(node)
       node.parts.any? do |part|
-        part.is_a?(TStringContent) && part.value.match?(/#[@${]|[\\]/)
+        part.is_a?(TStringContent) && part.value.match?(/\\|#[@${]/)
       end
     end
 
@@ -3525,7 +3969,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parts: parts, quote: quote, location: location, comments: comments }
     end
 
@@ -3566,9 +4010,14 @@ module SyntaxTree
         matching = Quotes.matching(quote[2])
         pattern = /[\n#{Regexp.escape(matching)}'"]/
 
-        if parts.any? { |part|
-             part.is_a?(TStringContent) && part.value.match?(pattern)
-           }
+        # This check is to ensure we don't find a matching quote inside of the
+        # symbol that would be confusing.
+        matched =
+          parts.any? do |part|
+            part.is_a?(TStringContent) && part.value.match?(pattern)
+          end
+
+        if matched
           [quote, matching]
         elsif Quotes.locked?(self)
           ["#{":" unless hash_key}'", "'"]
@@ -3577,7 +4026,7 @@ module SyntaxTree
         end
       elsif Quotes.locked?(self)
         if quote.start_with?(":")
-          [hash_key ? quote[1..-1] : quote, quote[1..-1]]
+          [hash_key ? quote[1..] : quote, quote[1..]]
         else
           [hash_key ? quote : ":#{quote}", quote]
         end
@@ -3620,7 +4069,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         keyword: keyword,
         statements: statements,
@@ -3686,7 +4135,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         predicate: predicate,
         statements: statements,
@@ -3758,7 +4207,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
 
@@ -3792,8 +4241,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -3822,8 +4271,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -3854,8 +4303,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -3894,7 +4343,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         keyword: keyword,
         statements: statements,
@@ -3948,7 +4397,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -3991,7 +4440,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         value: value,
         arguments: arguments,
@@ -4002,7 +4451,16 @@ module SyntaxTree
 
     def format(q)
       q.format(value)
-      q.format(arguments)
+
+      if arguments.is_a?(ArgParen) && arguments.arguments.nil? &&
+           !value.is_a?(Const)
+        # If you're using an explicit set of parentheses on something that looks
+        # like a constant, then we need to match that in order to maintain valid
+        # Ruby. For example, you could do something like Foo(), on which we
+        # would need to keep the parentheses to make it look like a method call.
+      else
+        q.format(arguments)
+      end
     end
   end
 
@@ -4042,7 +4500,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         parent: parent,
         operator: operator,
@@ -4088,7 +4546,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -4140,7 +4598,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         constant: constant,
         left: left,
@@ -4204,7 +4662,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         index: index,
         collection: collection,
@@ -4261,7 +4719,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -4275,6 +4733,32 @@ module SyntaxTree
   #     { key => value }
   #
   class HashLiteral < Node
+    # This is a special formatter used if the hash literal contains no values
+    # but _does_ contain comments. In this case we do some special formatting to
+    # make sure the comments gets indented properly.
+    class EmptyWithCommentsFormatter
+      # [LBrace] the opening brace
+      attr_reader :lbrace
+
+      def initialize(lbrace)
+        @lbrace = lbrace
+      end
+
+      def format(q)
+        q.group do
+          q.text("{")
+          q.indent do
+            lbrace.comments.each do |comment|
+              q.breakable(force: true)
+              comment.format(q)
+            end
+          end
+          q.breakable(force: true)
+          q.text("}")
+        end
+      end
+    end
+
     # [LBrace] the left brace that opens this hash
     attr_reader :lbrace
 
@@ -4301,7 +4785,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { lbrace: lbrace, assocs: assocs, location: location, comments: comments }
     end
 
@@ -4319,7 +4803,18 @@ module SyntaxTree
 
     private
 
-    def format_contents(q)
+    # If we have an empty hash that contains only comments, then we're going
+    # to do some special printing to ensure they get indented correctly.
+    def empty_with_comments?
+      assocs.empty? && lbrace.comments.any? && lbrace.comments.none?(&:inline?)
+    end
+
+    def format_contents(q)
+      if empty_with_comments?
+        EmptyWithCommentsFormatter.new(lbrace).format(q)
+        return
+      end
+
       q.format(lbrace)
 
       if assocs.empty?
@@ -4359,7 +4854,14 @@ module SyntaxTree
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(beginning:, ending: nil, dedent: 0, parts: [], location:, comments: [])
+    def initialize(
+      beginning:,
+      ending: nil,
+      dedent: 0,
+      parts: [],
+      location:,
+      comments: []
+    )
       @beginning = beginning
       @ending = ending
       @dedent = dedent
@@ -4378,7 +4880,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         beginning: beginning,
         location: location,
@@ -4393,8 +4895,12 @@ module SyntaxTree
       # prettyprint module. It's when you want to force a newline, but don't
       # want to force the break parent.
       breakable = -> do
-        q.target <<
-          PrettyPrint::Breakable.new(" ", 1, indent: false, force: true)
+        q.target << PrettyPrint::Breakable.new(
+          " ",
+          1,
+          indent: false,
+          force: true
+        )
       end
 
       q.group do
@@ -4450,7 +4956,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -4467,6 +4973,7 @@ module SyntaxTree
   #     end
   #
   class HshPtn < Node
+    # Formats a key-value pair in a hash pattern. The value is optional.
     class KeywordFormatter
       # [Label] the keyword being used
       attr_reader :key
@@ -4493,6 +5000,7 @@ module SyntaxTree
       end
     end
 
+    # Formats the optional double-splat from the pattern.
     class KeywordRestFormatter
       # [VarField] the parameter that matches the remaining keywords
       attr_reader :keyword_rest
@@ -4542,7 +5050,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         constant: constant,
         keywords: keywords,
@@ -4565,27 +5073,52 @@ module SyntaxTree
         q.text(" then") if !constant && keyword_rest && keyword_rest.value.nil?
       end
 
+      # If there is a constant, we're going to format to have the constant name
+      # first and then use brackets.
       if constant
-        q.format(constant)
-        q.group(0, "[", "]", &contents)
+        q.group do
+          q.format(constant)
+          q.text("[")
+          q.indent do
+            q.breakable("")
+            contents.call
+          end
+          q.breakable("")
+          q.text("]")
+        end
         return
       end
 
+      # If there's nothing at all, then we're going to use empty braces.
       if parts.empty?
         q.text("{}")
-      elsif PATTERNS.include?(q.parent.class)
-        q.text("{ ")
-        contents.call
-        q.text(" }")
-      else
+        return
+      end
+
+      # If there's only one pair, then we'll just print the contents provided
+      # we're not inside another pattern.
+      if !PATTERNS.include?(q.parent.class) && parts.size == 1
         contents.call
+        return
+      end
+
+      # Otherwise, we're going to always use braces to make it clear it's a hash
+      # pattern.
+      q.group do
+        q.text("{")
+        q.indent do
+          q.breakable
+          contents.call
+        end
+        q.breakable
+        q.text("}")
       end
     end
   end
 
   # The list of nodes that represent patterns inside of pattern matching so that
   # when a pattern is being printed it knows if it's nested.
-  PATTERNS = [AryPtn, Binary, FndPtn, HshPtn, RAssign]
+  PATTERNS = [AryPtn, Binary, FndPtn, HshPtn, RAssign].freeze
 
   # Ident represents an identifier anywhere in code. It can represent a very
   # large number of things, depending on where it is in the syntax tree.
@@ -4615,7 +5148,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -4632,7 +5165,7 @@ module SyntaxTree
     def self.call(parent)
       queue = [parent]
 
-      while node = queue.shift
+      while (node = queue.shift)
         return true if [Assign, MAssign, OpAssign].include?(node.class)
         queue += node.child_nodes
       end
@@ -4641,6 +5174,65 @@ module SyntaxTree
     end
   end
 
+  # In order for an `if` or `unless` expression to be shortened to a ternary,
+  # there has to be one and only one consequent clause which is an Else. Both
+  # the body of the main node and the body of the Else node must have only one
+  # statement, and that statement must not be on the denied list of potential
+  # statements.
+  module Ternaryable
+    class << self
+      def call(q, node)
+        case q.parents.take(2)[1]
+        in Paren[contents: Statements[body: [node]]]
+          # If this is a conditional inside of a parentheses as the only
+          # content, then we don't want to transform it into a ternary.
+          # Presumably the user wanted it to be an explicit conditional because
+          # there are parentheses around it. So we'll just leave it in place.
+          false
+        else
+          # Otherwise, we're going to check the conditional for certain cases.
+          case node
+          in predicate: Assign | Command | CommandCall | MAssign | OpAssign
+            false
+          in {
+               statements: { body: [truthy] },
+               consequent: Else[statements: { body: [falsy] }]
+             }
+            ternaryable?(truthy) && ternaryable?(falsy)
+          else
+            false
+          end
+        end
+      end
+
+      private
+
+      # Certain expressions cannot be reduced to a ternary without adding
+      # parentheses around them. In this case we say they cannot be ternaried
+      # and default instead to breaking them into multiple lines.
+      def ternaryable?(statement)
+        # This is a list of nodes that should not be allowed to be a part of a
+        # ternary clause.
+        no_ternary = [
+          Alias, Assign, Break, Command, CommandCall, Heredoc, If, IfMod, IfOp,
+          Lambda, MAssign, Next, OpAssign, RescueMod, Return, Return0, Super,
+          Undef, Unless, UnlessMod, Until, UntilMod, VarAlias, VoidStmt, While,
+          WhileMod, Yield, Yield0, ZSuper
+        ]
+
+        # Here we're going to check that the only statement inside the
+        # statements node is no a part of our denied list of nodes that can be
+        # ternaries.
+        #
+        # If the user is using one of the lower precedence "and" or "or"
+        # operators, then we can't use a ternary expression as it would break
+        # the flow control.
+        !no_ternary.include?(statement.class) &&
+          !(statement.is_a?(Binary) && %i[and or].include?(statement.operator))
+      end
+    end
+  end
+
   # Formats an If or Unless node.
   class ConditionalFormatter
     # [String] the keyword associated with this conditional
@@ -4655,6 +5247,13 @@ module SyntaxTree
     end
 
     def format(q)
+      # If we can transform this node into a ternary, then we're going to print
+      # a special version that uses the ternary operator if it fits on one line.
+      if Ternaryable.call(q, node)
+        format_ternary(q)
+        return
+      end
+
       # If the predicate of the conditional contains an assignment (in which
       # case we can't know for certain that that assignment doesn't impact the
       # statements inside the conditional) then we can't use the modifier form
@@ -4664,17 +5263,19 @@ module SyntaxTree
         return
       end
 
-      if node.consequent || node.statements.empty?
+      if node.consequent || node.statements.empty? || contains_conditional?
         q.group { format_break(q, force: true) }
       else
         q.group do
-          q.if_break { format_break(q, force: false) }.if_flat do
-            Parentheses.flat(q) do
-              q.format(node.statements)
-              q.text(" #{keyword} ")
-              q.format(node.predicate)
+          q
+            .if_break { format_break(q, force: false) }
+            .if_flat do
+              Parentheses.flat(q) do
+                q.format(node.statements)
+                q.text(" #{keyword} ")
+                q.format(node.predicate)
+              end
             end
-          end
         end
       end
     end
@@ -4700,6 +5301,61 @@ module SyntaxTree
       q.breakable(force: force)
       q.text("end")
     end
+
+    def format_ternary(q)
+      q.group do
+        q
+          .if_break do
+            q.text("#{keyword} ")
+            q.nest(keyword.length + 1) { q.format(node.predicate) }
+
+            q.indent do
+              q.breakable
+              q.format(node.statements)
+            end
+
+            q.breakable
+            q.group do
+              q.format(node.consequent.keyword)
+              q.indent do
+                # This is a very special case of breakable where we want to
+                # force it into the output but we _don't_ want to explicitly
+                # break the parent. If a break-parent shows up in the tree, then
+                # it's going to force it all the way up to the tree, which is
+                # going to negate the ternary. Maybe this should be an option in
+                # prettyprint? As in force: :no_break_parent or something.
+                q.target << PrettyPrint::Breakable.new(" ", 1, force: true)
+                q.format(node.consequent.statements)
+              end
+            end
+
+            q.breakable
+            q.text("end")
+          end
+          .if_flat do
+            Parentheses.flat(q) do
+              q.format(node.predicate)
+              q.text(" ? ")
+
+              statements = [node.statements, node.consequent.statements]
+              statements.reverse! if keyword == "unless"
+
+              q.format(statements[0])
+              q.text(" : ")
+              q.format(statements[1])
+            end
+          end
+      end
+    end
+
+    def contains_conditional?
+      case node
+      in statements: { body: [If | IfMod | IfOp | Unless | UnlessMod] }
+        true
+      else
+        false
+      end
+    end
   end
 
   # If represents the first clause in an +if+ chain.
@@ -4744,7 +5400,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         predicate: predicate,
         statements: statements,
@@ -4794,7 +5450,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         predicate: predicate,
         truthy: truthy,
@@ -4812,7 +5468,8 @@ module SyntaxTree
         Yield0, ZSuper
       ]
 
-      if force_flat.include?(truthy.class) || force_flat.include?(falsy.class)
+      if q.parent.is_a?(Paren) || force_flat.include?(truthy.class) ||
+           force_flat.include?(falsy.class)
         q.group { format_flat(q) }
         return
       end
@@ -4932,7 +5589,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         statement: statement,
         predicate: predicate,
@@ -4973,7 +5630,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5020,7 +5677,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         pattern: pattern,
         statements: statements,
@@ -5079,7 +5736,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5089,7 +5746,7 @@ module SyntaxTree
         # the values, then we're going to insert them every 3 characters
         # starting from the right.
         index = (value.length + 2) % 3
-        q.text("  #{value}"[index..-1].scan(/.../).join("_").strip)
+        q.text("  #{value}"[index..].scan(/.../).join("_").strip)
       else
         q.text(value)
       end
@@ -5123,7 +5780,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5168,7 +5825,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5205,7 +5862,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { name: name, location: location, comments: comments }
     end
 
@@ -5251,7 +5908,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5285,8 +5942,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -5322,7 +5979,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         params: params,
         statements: statements,
@@ -5344,25 +6001,27 @@ module SyntaxTree
         end
 
         q.text(" ")
-        q.if_break do
-          force_parens =
-            q.parents.any? do |node|
-              node.is_a?(Command) || node.is_a?(CommandCall)
+        q
+          .if_break do
+            force_parens =
+              q.parents.any? do |node|
+                node.is_a?(Command) || node.is_a?(CommandCall)
+              end
+
+            q.text(force_parens ? "{" : "do")
+            q.indent do
+              q.breakable
+              q.format(statements)
             end
 
-          q.text(force_parens ? "{" : "do")
-          q.indent do
             q.breakable
+            q.text(force_parens ? "}" : "end")
+          end
+          .if_flat do
+            q.text("{ ")
             q.format(statements)
+            q.text(" }")
           end
-
-          q.breakable
-          q.text(force_parens ? "}" : "end")
-        end.if_flat do
-          q.text("{ ")
-          q.format(statements)
-          q.text(" }")
-        end
       end
     end
   end
@@ -5391,7 +6050,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5424,7 +6083,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5457,7 +6116,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5507,7 +6166,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { target: target, value: value, location: location, comments: comments }
     end
 
@@ -5554,11 +6213,27 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { call: call, block: block, location: location, comments: comments }
     end
 
     def format(q)
+      # If we're at the top of a call chain, then we're going to do some
+      # specialized printing in case we can print it nicely. We _only_ do this
+      # at the top of the chain to avoid weird recursion issues.
+      if !CallChainFormatter.chained?(q.parent) &&
+           CallChainFormatter.chained?(call)
+        q.group do
+          q
+            .if_break { CallChainFormatter.new(self).format(q) }
+            .if_flat { format_contents(q) }
+        end
+      else
+        format_contents(q)
+      end
+    end
+
+    def format_contents(q)
       q.format(call)
       q.format(block)
     end
@@ -5599,7 +6274,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parts: parts, location: location, comma: comma, comments: comments }
     end
 
@@ -5643,7 +6318,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { contents: contents, location: location, comments: comments }
     end
 
@@ -5699,7 +6374,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         constant: constant,
         bodystmt: bodystmt,
@@ -5766,7 +6441,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parts: parts, location: location, comments: comments }
     end
 
@@ -5815,7 +6490,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { arguments: arguments, location: location, comments: comments }
     end
 
@@ -5852,7 +6527,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -5898,7 +6573,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         target: target,
         operator: operator,
@@ -5966,7 +6641,16 @@ module SyntaxTree
   # This approach maintains the nice conciseness of the inline version, while
   # keeping the correct semantic meaning.
   module Parentheses
-    NODES = [Args, Assign, Assoc, Binary, Call, Defined, MAssign, OpAssign]
+    NODES = [
+      Args,
+      Assign,
+      Assoc,
+      Binary,
+      Call,
+      Defined,
+      MAssign,
+      OpAssign
+    ].freeze
 
     def self.flat(q)
       return yield unless NODES.include?(q.parent.class)
@@ -5998,6 +6682,8 @@ module SyntaxTree
   #     def method(param) end
   #
   class Params < Node
+    # Formats the optional position of the parameters. This includes the label,
+    # as well as the default value.
     class OptionalFormatter
       # [Ident] the name of the parameter
       attr_reader :name
@@ -6021,6 +6707,8 @@ module SyntaxTree
       end
     end
 
+    # Formats the keyword position of the parameters. This includes the label,
+    # as well as an optional default value.
     class KeywordFormatter
       # [Ident] the name of the parameter
       attr_reader :name
@@ -6047,6 +6735,8 @@ module SyntaxTree
       end
     end
 
+    # Formats the keyword_rest position of the parameters. This can be the **nil
+    # syntax, the ... syntax, or the ** syntax.
     class KeywordRestFormatter
       # [:nil | ArgsForward | KwRestParam] the value of the parameter
       attr_reader :value
@@ -6060,11 +6750,7 @@ module SyntaxTree
       end
 
       def format(q)
-        if value == :nil
-          q.text("**nil")
-        else
-          q.format(value)
-        end
+        value == :nil ? q.text("**nil") : q.format(value)
       end
     end
 
@@ -6145,7 +6831,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         location: location,
         requireds: requireds,
@@ -6166,21 +6852,22 @@ module SyntaxTree
       ]
 
       parts << rest if rest && !rest.is_a?(ExcessedComma)
-      parts +=
-        [
-          *posts,
-          *keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
-        ]
+      parts += [
+        *posts,
+        *keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
+      ]
 
       parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
       parts << block if block
 
       contents = -> do
         q.seplist(parts) { |part| q.format(part) }
-        q.format(rest) if rest && rest.is_a?(ExcessedComma)
+        q.format(rest) if rest.is_a?(ExcessedComma)
       end
 
-      if [Def, Defs, DefEndless].include?(q.parent.class)
+      if ![Def, Defs, DefEndless].include?(q.parent.class) || parts.empty?
+        q.nest(0, &contents)
+      else
         q.group(0, "(", ")") do
           q.indent do
             q.breakable("")
@@ -6188,8 +6875,6 @@ module SyntaxTree
           end
           q.breakable("")
         end
-      else
-        q.nest(0, &contents)
       end
     end
   end
@@ -6227,7 +6912,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         lparen: lparen,
         contents: contents,
@@ -6278,7 +6963,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -6311,7 +6996,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { statements: statements, location: location, comments: comments }
     end
 
@@ -6356,7 +7041,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         beginning: beginning,
         elements: elements,
@@ -6410,18 +7095,9 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
-      { value: value, location: location }
-    end
-
-    def pretty_print(q)
-      q.group(2, "(", ")") do
-        q.text("qsymbols_beg")
 
-        q.breakable
-        q.pp(value)
-      end
+    def deconstruct_keys(_keys)
+      { value: value, location: location }
     end
   end
 
@@ -6456,7 +7132,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         beginning: beginning,
         elements: elements,
@@ -6510,8 +7186,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -6543,7 +7219,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -6571,8 +7247,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -6596,8 +7272,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -6629,7 +7305,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -6667,8 +7343,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { beginning: beginning, parts: parts, location: location }
     end
   end
@@ -6700,8 +7376,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -6734,8 +7410,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -6776,10 +7452,11 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         beginning: beginning,
         ending: ending,
+        options: options,
         parts: parts,
         location: location,
         comments: comments
@@ -6787,7 +7464,7 @@ module SyntaxTree
     end
 
     def format(q)
-      braces = ambiguous?(q) || include?(%r{\/})
+      braces = ambiguous?(q) || include?(%r{/})
 
       if braces && include?(/[{}]/)
         q.group do
@@ -6814,18 +7491,22 @@ module SyntaxTree
           end
 
           q.text("}")
-          q.text(ending[1..-1])
+          q.text(options)
         end
       else
         q.group do
           q.text("/")
           q.format_each(parts)
           q.text("/")
-          q.text(ending[1..-1])
+          q.text(options)
         end
       end
     end
 
+    def options
+      ending[1..]
+    end
+
     private
 
     def include?(pattern)
@@ -6881,7 +7562,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         exceptions: exceptions,
         variable: variable,
@@ -6956,7 +7637,10 @@ module SyntaxTree
 
       if consequent
         consequent.bind_end(end_char, end_column)
-        statements.bind_end(consequent.location.start_char, consequent.location.start_column)
+        statements.bind_end(
+          consequent.location.start_char,
+          consequent.location.start_column
+        )
       else
         statements.bind_end(end_char, end_column)
       end
@@ -6972,7 +7656,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         keyword: keyword,
         exception: exception,
@@ -7039,7 +7723,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         statement: statement,
         value: value,
@@ -7093,7 +7777,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { name: name, location: location, comments: comments }
     end
 
@@ -7130,7 +7814,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -7166,7 +7850,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { arguments: arguments, location: location, comments: comments }
     end
 
@@ -7202,7 +7886,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -7220,7 +7904,7 @@ module SyntaxTree
       @value = value
       @location = location
     end
-  
+
     def accept(visitor)
       visitor.visit_rparen(self)
     end
@@ -7230,8 +7914,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -7270,7 +7954,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         target: target,
         bodystmt: bodystmt,
@@ -7372,7 +8056,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parser: parser, body: body, location: location, comments: comments }
     end
 
@@ -7444,8 +8128,6 @@ module SyntaxTree
 
         if !comment.inline? && (start_char <= location.start_char) &&
              (end_char >= location.end_char) && !comment.ignore?
-          parser_comments.delete_at(comment_index)
-
           while (node = body[body_index]) &&
                   (
                     node.is_a?(VoidStmt) ||
@@ -7454,7 +8136,17 @@ module SyntaxTree
             body_index += 1
           end
 
-          body.insert(body_index, comment)
+          if body_index != 0 &&
+               body[body_index - 1].location.start_char < location.start_char &&
+               body[body_index - 1].location.end_char > location.start_char
+            # The previous node entirely encapsules the comment, so we don't
+            # want to attach it here since it will get attached normally. This
+            # is mostly in the case of hash and array literals.
+            comment_index += 1
+          else
+            parser_comments.delete_at(comment_index)
+            body.insert(body_index, comment)
+          end
         else
           comment_index += 1
         end
@@ -7485,8 +8177,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { parts: parts, location: location }
     end
   end
@@ -7524,14 +8216,14 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { left: left, right: right, location: location, comments: comments }
     end
 
     def format(q)
       q.group do
         q.format(left)
-        q.text(' \\')
+        q.text(" \\")
         q.indent do
           q.breakable(force: true)
           q.format(right)
@@ -7569,7 +8261,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { variable: variable, location: location, comments: comments }
     end
 
@@ -7609,7 +8301,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { statements: statements, location: location, comments: comments }
     end
 
@@ -7667,7 +8359,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parts: parts, quote: quote, location: location, comments: comments }
     end
 
@@ -7730,7 +8422,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { arguments: arguments, location: location, comments: comments }
     end
 
@@ -7782,8 +8474,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -7812,8 +8504,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -7847,7 +8539,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -7888,7 +8580,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         beginning: beginning,
         elements: elements,
@@ -7943,8 +8635,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -7972,8 +8664,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -8002,8 +8694,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -8037,7 +8729,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { constant: constant, location: location, comments: comments }
     end
 
@@ -8075,7 +8767,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { constant: constant, location: location, comments: comments }
     end
 
@@ -8113,8 +8805,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -8154,7 +8846,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -8191,8 +8883,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -8228,7 +8920,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         statement: statement,
         parentheses: parentheses,
@@ -8238,9 +8930,28 @@ module SyntaxTree
     end
 
     def format(q)
-      q.text(parentheses ? "not(" : "not ")
+      parent = q.parents.take(2)[1]
+      ternary =
+        (parent.is_a?(If) || parent.is_a?(Unless)) &&
+          Ternaryable.call(q, parent)
+
+      q.text("not")
+
+      if parentheses
+        q.text("(")
+      elsif ternary
+        q.if_break { q.text(" ") }.if_flat { q.text("(") }
+      else
+        q.text(" ")
+      end
+
       q.format(statement) if statement
-      q.text(")") if parentheses
+
+      if parentheses
+        q.text(")")
+      elsif ternary
+        q.if_flat { q.text(")") }
+      end
     end
   end
 
@@ -8276,7 +8987,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         operator: operator,
         statement: statement,
@@ -8296,6 +9007,9 @@ module SyntaxTree
   #     undef method
   #
   class Undef < Node
+    # Undef accepts a variable number of arguments that can be either DynaSymbol
+    # or SymbolLiteral objects. For SymbolLiteral objects we descend directly
+    # into the value in order to have it come out as bare words.
     class UndefArgumentFormatter
       # [DynaSymbol | SymbolLiteral] the symbol to undefine
       attr_reader :node
@@ -8339,7 +9053,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { symbols: symbols, location: location, comments: comments }
     end
 
@@ -8398,7 +9112,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         predicate: predicate,
         statements: statements,
@@ -8444,7 +9158,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         statement: statement,
         predicate: predicate,
@@ -8483,13 +9197,15 @@ module SyntaxTree
       end
 
       q.group do
-        q.if_break { format_break(q) }.if_flat do
-          Parentheses.flat(q) do
-            q.format(statements)
-            q.text(" #{keyword} ")
-            q.format(node.predicate)
+        q
+          .if_break { format_break(q) }
+          .if_flat do
+            Parentheses.flat(q) do
+              q.format(statements)
+              q.text(" #{keyword} ")
+              q.format(node.predicate)
+            end
           end
-        end
       end
     end
 
@@ -8539,7 +9255,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         predicate: predicate,
         statements: statements,
@@ -8595,7 +9311,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         statement: statement,
         predicate: predicate,
@@ -8661,7 +9377,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { left: left, right: right, location: location, comments: comments }
     end
 
@@ -8704,7 +9420,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -8748,7 +9464,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -8789,7 +9505,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -8829,7 +9545,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -8864,7 +9580,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { location: location, comments: comments }
     end
 
@@ -8915,7 +9631,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         arguments: arguments,
         statements: statements,
@@ -8996,7 +9712,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         predicate: predicate,
         statements: statements,
@@ -9052,7 +9768,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         statement: statement,
         predicate: predicate,
@@ -9121,7 +9837,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parts: parts, location: location, comments: comments }
     end
 
@@ -9161,7 +9877,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       {
         beginning: beginning,
         elements: elements,
@@ -9216,8 +9932,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { value: value, location: location }
     end
   end
@@ -9245,8 +9961,8 @@ module SyntaxTree
     end
 
     alias deconstruct child_nodes
-    
-    def deconstruct_keys(keys)
+
+    def deconstruct_keys(_keys)
       { parts: parts, location: location }
     end
   end
@@ -9279,7 +9995,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { parts: parts, location: location, comments: comments }
     end
 
@@ -9317,7 +10033,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { arguments: arguments, location: location, comments: comments }
     end
 
@@ -9367,7 +10083,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end
 
@@ -9403,7 +10119,7 @@ module SyntaxTree
 
     alias deconstruct child_nodes
 
-    def deconstruct_keys(keys)
+    def deconstruct_keys(_keys)
       { value: value, location: location, comments: comments }
     end