prism 2.0.0.rc1-aarch64-linux-gnu → 2.0.0.rc2-aarch64-linux-gnu

data/sig/generated/prism/node.rbs

@@ -274,8 +274,10 @@ module Prism
 
   # Represents the use of the `alias` keyword to alias a global variable.
   #
-  #     alias $foo $bar
-  #     ^^^^^^^^^^^^^^^
+  # ```rb
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  # ```
   class AliasGlobalVariableNode < Node
     @keyword_loc: Location
 
@@ -341,8 +343,10 @@ module Prism
     #
     # Represents the new name of the global variable that can be used after aliasing.
     #
-    #     alias $foo $bar
-    #           ^^^^
+    # ```rb
+    # alias $foo $bar
+    #       ^^^^
+    # ```
     #
     # : () -> (GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode)
     def new_name: () -> (GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode)
@@ -352,8 +356,10 @@ module Prism
     #
     # Represents the old name of the global variable that can be used before aliasing.
     #
-    #     alias $foo $bar
-    #                ^^^^
+    # ```rb
+    # alias $foo $bar
+    #            ^^^^
+    # ```
     #
     # : () -> (GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode)
     def old_name: () -> (GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode)
@@ -364,8 +370,10 @@ module Prism
     #
     # The Location of the `alias` keyword.
     #
-    #     alias $foo $bar
-    #     ^^^^^
+    # ```rb
+    # alias $foo $bar
+    # ^^^^^
+    # ```
     #
     # : () -> Location
     def keyword_loc: () -> Location
@@ -391,8 +399,10 @@ module Prism
 
   # Represents the use of the `alias` keyword to alias a method.
   #
-  #     alias foo bar
-  #     ^^^^^^^^^^^^^
+  # ```rb
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  # ```
   class AliasMethodNode < Node
     @keyword_loc: Location
 
@@ -458,14 +468,16 @@ module Prism
     #
     # Represents the new name of the method that will be aliased.
     #
-    #     alias foo bar
-    #           ^^^
+    # ```rb
+    # alias foo bar
+    #       ^^^
     #
-    #     alias :foo :bar
-    #           ^^^^
+    # alias :foo :bar
+    #       ^^^^
     #
-    #     alias :"#{foo}" :"#{bar}"
-    #           ^^^^^^^^^
+    # alias :"#{foo}" :"#{bar}"
+    #       ^^^^^^^^^
+    # ```
     #
     # : () -> (SymbolNode | InterpolatedSymbolNode)
     def new_name: () -> (SymbolNode | InterpolatedSymbolNode)
@@ -475,14 +487,16 @@ module Prism
     #
     # Represents the old name of the method that will be aliased.
     #
-    #     alias foo bar
-    #               ^^^
+    # ```rb
+    # alias foo bar
+    #           ^^^
     #
-    #     alias :foo :bar
-    #                ^^^^
+    # alias :foo :bar
+    #            ^^^^
     #
-    #     alias :"#{foo}" :"#{bar}"
-    #                     ^^^^^^^^^
+    # alias :"#{foo}" :"#{bar}"
+    #                 ^^^^^^^^^
+    # ```
     #
     # : () -> (SymbolNode | InterpolatedSymbolNode)
     def old_name: () -> (SymbolNode | InterpolatedSymbolNode)
@@ -493,8 +507,10 @@ module Prism
     #
     # Represents the Location of the `alias` keyword.
     #
-    #     alias foo bar
-    #     ^^^^^
+    # ```rb
+    # alias foo bar
+    # ^^^^^
+    # ```
     #
     # : () -> Location
     def keyword_loc: () -> Location
@@ -520,8 +536,10 @@ module Prism
 
   # Represents an alternation pattern in pattern matching.
   #
-  #     foo => bar | baz
-  #            ^^^^^^^^^
+  # ```rb
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  # ```
   class AlternationPatternNode < Node
     @operator_loc: Location
 
@@ -587,8 +605,10 @@ module Prism
     #
     # Represents the left side of the expression.
     #
-    #     foo => bar | baz
-    #            ^^^
+    # ```rb
+    # foo => bar | baz
+    #        ^^^
+    # ```
     #
     # : () -> Prism::node
     def left: () -> Prism::node
@@ -598,8 +618,10 @@ module Prism
     #
     # Represents the right side of the expression.
     #
-    #     foo => bar | baz
-    #                  ^^^
+    # ```rb
+    # foo => bar | baz
+    #              ^^^
+    # ```
     #
     # : () -> Prism::node
     def right: () -> Prism::node
@@ -610,8 +632,10 @@ module Prism
     #
     # Represents the alternation operator Location.
     #
-    #     foo => bar | baz
-    #                ^
+    # ```rb
+    # foo => bar | baz
+    #            ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -637,8 +661,10 @@ module Prism
 
   # Represents the use of the `&&` operator or the `and` keyword.
   #
-  #     left and right
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # left and right
+  # ^^^^^^^^^^^^^^
+  # ```
   class AndNode < Node
     @operator_loc: Location
 
@@ -704,11 +730,13 @@ module Prism
     #
     # Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     left and right
-    #     ^^^^
+    # ```rb
+    # left and right
+    # ^^^^
     #
-    #     1 && 2
-    #     ^
+    # 1 && 2
+    # ^
+    # ```
     #
     # : () -> Prism::node
     def left: () -> Prism::node
@@ -718,11 +746,13 @@ module Prism
     #
     # Represents the right side of the expression.
     #
-    #     left && right
-    #             ^^^^^
+    # ```rb
+    # left && right
+    #         ^^^^^
     #
-    #     1 and 2
-    #           ^
+    # 1 and 2
+    #       ^
+    # ```
     #
     # : () -> Prism::node
     def right: () -> Prism::node
@@ -733,8 +763,10 @@ module Prism
     #
     # The Location of the `and` keyword or the `&&` operator.
     #
-    #     left and right
-    #          ^^^
+    # ```rb
+    # left and right
+    #      ^^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -760,8 +792,10 @@ module Prism
 
   # Represents a set of arguments to a method or a keyword.
   #
-  #     return foo, bar, baz
-  #            ^^^^^^^^^^^^^
+  # ```rb
+  # return foo, bar, baz
+  #        ^^^^^^^^^^^^^
+  # ```
   class ArgumentsNode < Node
     @arguments: Array[Prism::node]
 
@@ -853,8 +887,10 @@ module Prism
     #
     # The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo(bar, baz)
-    #         ^^^^^^^^
+    # ```rb
+    # foo(bar, baz)
+    #     ^^^^^^^^
+    # ```
     #
     # : () -> Array[Prism::node]
     def arguments: () -> Array[Prism::node]
@@ -865,8 +901,10 @@ module Prism
 
   # Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
   #
-  #     [1, 2, 3]
-  #     ^^^^^^^^^
+  # ```rb
+  # [1, 2, 3]
+  # ^^^^^^^^^
+  # ```
   class ArrayNode < Node
     @closing_loc: Location?
 
@@ -947,10 +985,12 @@ module Prism
     #
     # Represents the optional source Location for the opening token.
     #
-    #     [1,2,3]                 # "["
-    #     %w[foo bar baz]         # "%w["
-    #     %I(apple orange banana) # "%I("
-    #     foo = 1, 2, 3           # nil
+    # ```rb
+    # [1,2,3]                 # "["
+    # %w[foo bar baz]         # "%w["
+    # %I(apple orange banana) # "%I("
+    # foo = 1, 2, 3           # nil
+    # ```
     #
     # : () -> Location?
     def opening_loc: () -> Location?
@@ -968,10 +1008,12 @@ module Prism
     #
     # Represents the optional source Location for the closing token.
     #
-    #     [1,2,3]                 # "]"
-    #     %w[foo bar baz]         # "]"
-    #     %I(apple orange banana) # ")"
-    #     foo = 1, 2, 3           # nil
+    # ```rb
+    # [1,2,3]                 # "]"
+    # %w[foo bar baz]         # "]"
+    # %I(apple orange banana) # ")"
+    # foo = 1, 2, 3           # nil
+    # ```
     #
     # : () -> Location?
     def closing_loc: () -> Location?
@@ -1005,20 +1047,22 @@ module Prism
 
   # Represents an array pattern in pattern matching.
   #
-  #     foo in 1, 2
-  #            ^^^^
+  # ```rb
+  # foo in 1, 2
+  #        ^^^^
   #
-  #     foo in [1, 2]
-  #            ^^^^^^
+  # foo in [1, 2]
+  #        ^^^^^^
   #
-  #     foo in *bar
-  #            ^^^^
+  # foo in *bar
+  #        ^^^^
   #
-  #     foo in Bar[]
-  #            ^^^^^
+  # foo in Bar[]
+  #        ^^^^^
   #
-  #     foo in Bar[1, 2, 3]
-  #            ^^^^^^^^^^^^
+  # foo in Bar[1, 2, 3]
+  #        ^^^^^^^^^^^^
+  # ```
   class ArrayPatternNode < Node
     @closing_loc: Location?
 
@@ -1090,14 +1134,16 @@ module Prism
     #
     # Represents the optional constant preceding the Array
     #
-    #     foo in Bar[]
-    #            ^^^
+    # ```rb
+    # foo in Bar[]
+    #        ^^^
     #
-    #     foo in Bar[1, 2, 3]
-    #            ^^^
+    # foo in Bar[1, 2, 3]
+    #        ^^^
     #
-    #     foo in Bar::Baz[1, 2, 3]
-    #            ^^^^^^^^
+    # foo in Bar::Baz[1, 2, 3]
+    #        ^^^^^^^^
+    # ```
     #
     # : () -> (ConstantPathNode | ConstantReadNode)?
     def constant: () -> (ConstantPathNode | ConstantReadNode)?
@@ -1107,8 +1153,10 @@ module Prism
     #
     # Represents the required elements of the array pattern.
     #
-    #     foo in [1, 2]
-    #             ^  ^
+    # ```rb
+    # foo in [1, 2]
+    #         ^  ^
+    # ```
     #
     # : () -> Array[Prism::node]
     def requireds: () -> Array[Prism::node]
@@ -1118,8 +1166,10 @@ module Prism
     #
     # Represents the rest element of the array pattern.
     #
-    #     foo in *bar
-    #            ^^^^
+    # ```rb
+    # foo in *bar
+    #        ^^^^
+    # ```
     #
     # : () -> (ImplicitRestNode | SplatNode)?
     def rest: () -> (ImplicitRestNode | SplatNode)?
@@ -1129,8 +1179,10 @@ module Prism
     #
     # Represents the elements after the rest element of the array pattern.
     #
-    #     foo in *bar, baz
-    #                  ^^^
+    # ```rb
+    # foo in *bar, baz
+    #              ^^^
+    # ```
     #
     # : () -> Array[Prism::node]
     def posts: () -> Array[Prism::node]
@@ -1141,8 +1193,10 @@ module Prism
     #
     # Represents the opening Location of the array pattern.
     #
-    #     foo in [1, 2]
-    #            ^
+    # ```rb
+    # foo in [1, 2]
+    #        ^
+    # ```
     #
     # : () -> Location?
     def opening_loc: () -> Location?
@@ -1160,8 +1214,10 @@ module Prism
     #
     # Represents the closing Location of the array pattern.
     #
-    #     foo in [1, 2]
-    #                 ^
+    # ```rb
+    # foo in [1, 2]
+    #             ^
+    # ```
     #
     # : () -> Location?
     def closing_loc: () -> Location?
@@ -1195,8 +1251,10 @@ module Prism
 
   # Represents a hash key/value pair.
   #
-  #     { a => b }
-  #       ^^^^^^
+  # ```rb
+  # { a => b }
+  #   ^^^^^^
+  # ```
   class AssocNode < Node
     @operator_loc: Location?
 
@@ -1262,14 +1320,16 @@ module Prism
     #
     # The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     { a: b }
-    #       ^
+    # ```rb
+    # { a: b }
+    #   ^
     #
-    #     { foo => bar }
-    #       ^^^
+    # { foo => bar }
+    #   ^^^
     #
-    #     { def a; end => 1 }
-    #       ^^^^^^^^^^
+    # { def a; end => 1 }
+    #   ^^^^^^^^^^
+    # ```
     #
     # : () -> Prism::node
     def key: () -> Prism::node
@@ -1279,11 +1339,13 @@ module Prism
     #
     # The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     { foo => bar }
-    #              ^^^
+    # ```rb
+    # { foo => bar }
+    #          ^^^
     #
-    #     { x: 1 }
-    #          ^
+    # { x: 1 }
+    #      ^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -1294,8 +1356,10 @@ module Prism
     #
     # The Location of the `=>` operator, if present.
     #
-    #     { foo => bar }
-    #           ^^
+    # ```rb
+    # { foo => bar }
+    #       ^^
+    # ```
     #
     # : () -> Location?
     def operator_loc: () -> Location?
@@ -1321,8 +1385,10 @@ module Prism
 
   # Represents a splat in a hash literal.
   #
-  #     { **foo }
-  #       ^^^^^
+  # ```rb
+  # { **foo }
+  #   ^^^^^
+  # ```
   class AssocSplatNode < Node
     @operator_loc: Location
 
@@ -1386,8 +1452,10 @@ module Prism
     #
     # The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
     #
-    #     { **foo }
-    #         ^^^
+    # ```rb
+    # { **foo }
+    #     ^^^
+    # ```
     #
     # : () -> Prism::node?
     def value: () -> Prism::node?
@@ -1398,8 +1466,10 @@ module Prism
     #
     # The Location of the `**` operator.
     #
-    #     { **x }
-    #       ^^
+    # ```rb
+    # { **x }
+    #   ^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -1425,8 +1495,10 @@ module Prism
 
   # Represents reading a reference to a field in the previous match.
   #
-  #     $'
-  #     ^^
+  # ```rb
+  # $'
+  # ^^
+  # ```
   class BackReferenceReadNode < Node
     @name: Symbol
 
@@ -1488,9 +1560,11 @@ module Prism
     #
     # The name of the back-reference variable, including the leading `$`.
     #
-    #     $& # name `:$&`
+    # ```rb
+    # $& # name `:$&`
     #
-    #     $+ # name `:$+`
+    # $+ # name `:$+`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -1501,10 +1575,12 @@ module Prism
 
   # Represents a begin statement.
   #
-  #     begin
-  #       foo
-  #     end
-  #     ^^^^^
+  # ```rb
+  # begin
+  #   foo
+  # end
+  # ^^^^^
+  # ```
   class BeginNode < Node
     @end_keyword_loc: Location?
 
@@ -1577,8 +1653,10 @@ module Prism
     #
     # Represents the Location of the `begin` keyword.
     #
-    #     begin x end
-    #     ^^^^^
+    # ```rb
+    # begin x end
+    # ^^^^^
+    # ```
     #
     # : () -> Location?
     def begin_keyword_loc: () -> Location?
@@ -1595,8 +1673,10 @@ module Prism
     #
     # Represents the statements within the begin block.
     #
-    #     begin x end
-    #           ^
+    # ```rb
+    # begin x end
+    #       ^
+    # ```
     #
     # : () -> StatementsNode?
     def statements: () -> StatementsNode?
@@ -1606,8 +1686,10 @@ module Prism
     #
     # Represents the rescue clause within the begin block.
     #
-    #     begin x; rescue y; end
-    #              ^^^^^^^^
+    # ```rb
+    # begin x; rescue y; end
+    #          ^^^^^^^^
+    # ```
     #
     # : () -> RescueNode?
     def rescue_clause: () -> RescueNode?
@@ -1617,8 +1699,10 @@ module Prism
     #
     # Represents the else clause within the begin block.
     #
-    #     begin x; rescue y; else z; end
-    #                        ^^^^^^^^^^^
+    # ```rb
+    # begin x; rescue y; else z; end
+    #                    ^^^^^^^^^^^
+    # ```
     #
     # : () -> ElseNode?
     def else_clause: () -> ElseNode?
@@ -1628,8 +1712,10 @@ module Prism
     #
     # Represents the ensure clause within the begin block.
     #
-    #     begin x; ensure y; end
-    #              ^^^^^^^^
+    # ```rb
+    # begin x; ensure y; end
+    #          ^^^^^^^^
+    # ```
     #
     # : () -> EnsureNode?
     def ensure_clause: () -> EnsureNode?
@@ -1640,8 +1726,10 @@ module Prism
     #
     # Represents the Location of the `end` keyword.
     #
-    #     begin x end
-    #             ^^^
+    # ```rb
+    # begin x end
+    #         ^^^
+    # ```
     #
     # : () -> Location?
     def end_keyword_loc: () -> Location?
@@ -1675,8 +1763,10 @@ module Prism
 
   # Represents a block argument using `&`.
   #
-  #     bar(&args)
-  #         ^^^^^
+  # ```rb
+  # bar(&args)
+  #     ^^^^^
+  # ```
   class BlockArgumentNode < Node
     @operator_loc: Location
 
@@ -1740,8 +1830,10 @@ module Prism
     #
     # The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo(&args)
-    #          ^^^^
+    # ```rb
+    # foo(&args)
+    #      ^^^^
+    # ```
     #
     # : () -> Prism::node?
     def expression: () -> Prism::node?
@@ -1752,8 +1844,10 @@ module Prism
     #
     # Represents the Location of the `&` operator.
     #
-    #     foo(&args)
-    #         ^
+    # ```rb
+    # foo(&args)
+    #     ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -1779,8 +1873,10 @@ module Prism
 
   # Represents a block local variable.
   #
-  #     a { |; b| }
-  #            ^
+  # ```rb
+  # a { |; b| }
+  #        ^
+  # ```
   class BlockLocalVariableNode < Node
     @name: Symbol
 
@@ -1848,8 +1944,10 @@ module Prism
     #
     # The name of the block local variable.
     #
-    #     a { |; b| } # name `:b`
-    #            ^
+    # ```rb
+    # a { |; b| } # name `:b`
+    #        ^
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -1860,8 +1958,10 @@ module Prism
 
   # Represents a block of ruby code.
   #
-  #     [1, 2, 3].each { |i| puts x }
-  #                    ^^^^^^^^^^^^^^
+  # ```rb
+  # [1, 2, 3].each { |i| puts x }
+  #                ^^^^^^^^^^^^^^
+  # ```
   class BlockNode < Node
     @closing_loc: Location
 
@@ -1931,8 +2031,10 @@ module Prism
     #
     # The local variables declared in the block.
     #
-    #     [1, 2, 3].each { |i| puts x } # locals: [:i]
-    #                       ^
+    # ```rb
+    # [1, 2, 3].each { |i| puts x } # locals: [:i]
+    #                   ^
+    # ```
     #
     # : () -> Array[Symbol]
     def locals: () -> Array[Symbol]
@@ -1942,12 +2044,14 @@ module Prism
     #
     # The parameters of the block.
     #
-    #     [1, 2, 3].each { |i| puts x }
-    #                      ^^^
-    #     [1, 2, 3].each { puts _1 }
-    #                    ^^^^^^^^^^^
-    #     [1, 2, 3].each { puts it }
-    #                    ^^^^^^^^^^^
+    # ```rb
+    # [1, 2, 3].each { |i| puts x }
+    #                  ^^^
+    # [1, 2, 3].each { puts _1 }
+    #                ^^^^^^^^^^^
+    # [1, 2, 3].each { puts it }
+    #                ^^^^^^^^^^^
+    # ```
     #
     # : () -> (BlockParametersNode | NumberedParametersNode | ItParametersNode)?
     def parameters: () -> (BlockParametersNode | NumberedParametersNode | ItParametersNode)?
@@ -1957,8 +2061,10 @@ module Prism
     #
     # The body of the block.
     #
-    #     [1, 2, 3].each { |i| puts x }
-    #                          ^^^^^^
+    # ```rb
+    # [1, 2, 3].each { |i| puts x }
+    #                      ^^^^^^
+    # ```
     #
     # : () -> (StatementsNode | BeginNode)?
     def body: () -> (StatementsNode | BeginNode)?
@@ -1969,8 +2075,10 @@ module Prism
     #
     # Represents the Location of the opening `{` or `do`.
     #
-    #     [1, 2, 3].each { |i| puts x }
-    #                    ^
+    # ```rb
+    # [1, 2, 3].each { |i| puts x }
+    #                ^
+    # ```
     #
     # : () -> Location
     def opening_loc: () -> Location
@@ -1988,8 +2096,10 @@ module Prism
     #
     # Represents the Location of the closing `}` or `end`.
     #
-    #     [1, 2, 3].each { |i| puts x }
-    #                                 ^
+    # ```rb
+    # [1, 2, 3].each { |i| puts x }
+    #                             ^
+    # ```
     #
     # : () -> Location
     def closing_loc: () -> Location
@@ -2023,9 +2133,11 @@ module Prism
 
   # Represents a block parameter of a method, block, or lambda definition.
   #
-  #     def a(&b)
-  #           ^^
-  #     end
+  # ```rb
+  # def a(&b)
+  #       ^^
+  # end
+  # ```
   class BlockParameterNode < Node
     @operator_loc: Location
 
@@ -2097,9 +2209,11 @@ module Prism
     #
     # The name of the block parameter.
     #
-    #     def a(&b) # name `:b`
-    #            ^
-    #     end
+    # ```rb
+    # def a(&b) # name `:b`
+    #        ^
+    # end
+    # ```
     #
     # : () -> Symbol?
     def name: () -> Symbol?
@@ -2110,8 +2224,10 @@ module Prism
     #
     # Represents the Location of the block parameter name.
     #
-    #     def a(&b)
-    #            ^
+    # ```rb
+    # def a(&b)
+    #        ^
+    # ```
     #
     # : () -> Location?
     def name_loc: () -> Location?
@@ -2129,9 +2245,11 @@ module Prism
     #
     # Represents the Location of the `&` operator.
     #
-    #     def a(&b)
-    #           ^
-    #     end
+    # ```rb
+    # def a(&b)
+    #       ^
+    # end
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -2157,12 +2275,14 @@ module Prism
 
   # Represents a block's parameters declaration.
   #
-  #     -> (a, b = 1; local) { }
-  #        ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # -> (a, b = 1; local) { }
+  #    ^^^^^^^^^^^^^^^^^
   #
-  #     foo do |a, b = 1; local|
-  #            ^^^^^^^^^^^^^^^^^
-  #     end
+  # foo do |a, b = 1; local|
+  #        ^^^^^^^^^^^^^^^^^
+  # end
+  # ```
   class BlockParametersNode < Node
     @closing_loc: Location?
 
@@ -2230,12 +2350,14 @@ module Prism
     #
     # Represents the parameters of the block.
     #
-    #     -> (a, b = 1; local) { }
-    #         ^^^^^^^^
+    # ```rb
+    # -> (a, b = 1; local) { }
+    #     ^^^^^^^^
     #
-    #     foo do |a, b = 1; local|
-    #             ^^^^^^^^
-    #     end
+    # foo do |a, b = 1; local|
+    #         ^^^^^^^^
+    # end
+    # ```
     #
     # : () -> ParametersNode?
     def parameters: () -> ParametersNode?
@@ -2245,12 +2367,14 @@ module Prism
     #
     # Represents the local variables of the block.
     #
-    #     -> (a, b = 1; local) { }
-    #                   ^^^^^
+    # ```rb
+    # -> (a, b = 1; local) { }
+    #               ^^^^^
     #
-    #     foo do |a, b = 1; local|
-    #                       ^^^^^
-    #     end
+    # foo do |a, b = 1; local|
+    #                   ^^^^^
+    # end
+    # ```
     #
     # : () -> Array[BlockLocalVariableNode]
     def locals: () -> Array[BlockLocalVariableNode]
@@ -2261,12 +2385,14 @@ module Prism
     #
     # Represents the opening Location of the block parameters.
     #
-    #     -> (a, b = 1; local) { }
-    #        ^
+    # ```rb
+    # -> (a, b = 1; local) { }
+    #    ^
     #
-    #     foo do |a, b = 1; local|
-    #            ^
-    #     end
+    # foo do |a, b = 1; local|
+    #        ^
+    # end
+    # ```
     #
     # : () -> Location?
     def opening_loc: () -> Location?
@@ -2284,12 +2410,14 @@ module Prism
     #
     # Represents the closing Location of the block parameters.
     #
-    #     -> (a, b = 1; local) { }
-    #                        ^
+    # ```rb
+    # -> (a, b = 1; local) { }
+    #                    ^
     #
-    #     foo do |a, b = 1; local|
-    #                            ^
-    #     end
+    # foo do |a, b = 1; local|
+    #                        ^
+    # end
+    # ```
     #
     # : () -> Location?
     def closing_loc: () -> Location?
@@ -2323,8 +2451,10 @@ module Prism
 
   # Represents the use of the `break` keyword.
   #
-  #     break foo
-  #     ^^^^^^^^^
+  # ```rb
+  # break foo
+  # ^^^^^^^^^
+  # ```
   class BreakNode < Node
     @keyword_loc: Location
 
@@ -2388,8 +2518,10 @@ module Prism
     #
     # The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     break foo
-    #           ^^^
+    # ```rb
+    # break foo
+    #       ^^^
+    # ```
     #
     # : () -> ArgumentsNode?
     def arguments: () -> ArgumentsNode?
@@ -2400,8 +2532,10 @@ module Prism
     #
     # The Location of the `break` keyword.
     #
-    #     break foo
-    #     ^^^^^
+    # ```rb
+    # break foo
+    # ^^^^^
+    # ```
     #
     # : () -> Location
     def keyword_loc: () -> Location
@@ -2427,8 +2561,10 @@ module Prism
 
   # Represents the use of the `&&=` operator on a call.
   #
-  #     foo.bar &&= value
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # foo.bar &&= value
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class CallAndWriteNode < Node
     @value: Prism::node
 
@@ -2526,8 +2662,10 @@ module Prism
     #
     # The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo.bar &&= value
-    #     ^^^
+    # ```rb
+    # foo.bar &&= value
+    # ^^^
+    # ```
     #
     # : () -> Prism::node?
     def receiver: () -> Prism::node?
@@ -2538,8 +2676,10 @@ module Prism
     #
     # Represents the Location of the call operator.
     #
-    #     foo.bar &&= value
-    #        ^
+    # ```rb
+    # foo.bar &&= value
+    #    ^
+    # ```
     #
     # : () -> Location?
     def call_operator_loc: () -> Location?
@@ -2557,8 +2697,10 @@ module Prism
     #
     # Represents the Location of the message.
     #
-    #     foo.bar &&= value
-    #         ^^^
+    # ```rb
+    # foo.bar &&= value
+    #     ^^^
+    # ```
     #
     # : () -> Location?
     def message_loc: () -> Location?
@@ -2575,8 +2717,10 @@ module Prism
     #
     # Represents the name of the method being called.
     #
-    #     foo.bar &&= value # read_name `:bar`
-    #         ^^^
+    # ```rb
+    # foo.bar &&= value # read_name `:bar`
+    #     ^^^
+    # ```
     #
     # : () -> Symbol
     def read_name: () -> Symbol
@@ -2586,8 +2730,10 @@ module Prism
     #
     # Represents the name of the method being written to.
     #
-    #     foo.bar &&= value # write_name `:bar=`
-    #         ^^^
+    # ```rb
+    # foo.bar &&= value # write_name `:bar=`
+    #     ^^^
+    # ```
     #
     # : () -> Symbol
     def write_name: () -> Symbol
@@ -2598,8 +2744,10 @@ module Prism
     #
     # Represents the Location of the operator.
     #
-    #     foo.bar &&= value
-    #             ^^^
+    # ```rb
+    # foo.bar &&= value
+    #         ^^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -2616,8 +2764,10 @@ module Prism
     #
     # Represents the value being assigned.
     #
-    #     foo.bar &&= value
-    #                 ^^^^^
+    # ```rb
+    # foo.bar &&= value
+    #             ^^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -2652,23 +2802,25 @@ module Prism
 
   # Represents a method call, in all of the various forms that can take.
   #
-  #     foo
-  #     ^^^
+  # ```rb
+  # foo
+  # ^^^
   #
-  #     foo()
-  #     ^^^^^
+  # foo()
+  # ^^^^^
   #
-  #     +foo
-  #     ^^^^
+  # +foo
+  # ^^^^
   #
-  #     foo + bar
-  #     ^^^^^^^^^
+  # foo + bar
+  # ^^^^^^^^^
   #
-  #     foo.bar
-  #     ^^^^^^^
+  # foo.bar
+  # ^^^^^^^
   #
-  #     foo&.bar
-  #     ^^^^^^^^
+  # foo&.bar
+  # ^^^^^^^^
+  # ```
   class CallNode < Node
     @block: (BlockNode | BlockArgumentNode)?
 
@@ -2770,14 +2922,16 @@ module Prism
     #
     # The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo.bar
-    #     ^^^
+    # ```rb
+    # foo.bar
+    # ^^^
     #
-    #     +foo
-    #      ^^^
+    # +foo
+    #  ^^^
     #
-    #     foo + bar
-    #     ^^^
+    # foo + bar
+    # ^^^
+    # ```
     #
     # : () -> Prism::node?
     def receiver: () -> Prism::node?
@@ -2788,11 +2942,13 @@ module Prism
     #
     # Represents the Location of the call operator.
     #
-    #     foo.bar
-    #        ^
+    # ```rb
+    # foo.bar
+    #    ^
     #
-    #     foo&.bar
-    #        ^^
+    # foo&.bar
+    #    ^^
+    # ```
     #
     # : () -> Location?
     def call_operator_loc: () -> Location?
@@ -2809,8 +2965,10 @@ module Prism
     #
     # Represents the name of the method being called.
     #
-    #     foo.bar # name `:foo`
-    #     ^^^
+    # ```rb
+    # foo.bar # name `:foo`
+    # ^^^
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -2821,8 +2979,10 @@ module Prism
     #
     # Represents the Location of the message.
     #
-    #     foo.bar
-    #         ^^^
+    # ```rb
+    # foo.bar
+    #     ^^^
+    # ```
     #
     # : () -> Location?
     def message_loc: () -> Location?
@@ -2840,8 +3000,10 @@ module Prism
     #
     # Represents the Location of the left parenthesis.
     #
-    #     foo(bar)
-    #        ^
+    # ```rb
+    # foo(bar)
+    #    ^
+    # ```
     #
     # : () -> Location?
     def opening_loc: () -> Location?
@@ -2858,8 +3020,10 @@ module Prism
     #
     # Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo(bar)
-    #         ^^^
+    # ```rb
+    # foo(bar)
+    #     ^^^
+    # ```
     #
     # : () -> ArgumentsNode?
     def arguments: () -> ArgumentsNode?
@@ -2870,8 +3034,10 @@ module Prism
     #
     # Represents the Location of the right parenthesis.
     #
-    #     foo(bar)
-    #            ^
+    # ```rb
+    # foo(bar)
+    #        ^
+    # ```
     #
     # : () -> Location?
     def closing_loc: () -> Location?
@@ -2889,11 +3055,13 @@ module Prism
     #
     # Represents the Location of the equal sign, in the case that this is an attribute write.
     #
-    #     foo.bar = value
-    #             ^
+    # ```rb
+    # foo.bar = value
+    #         ^
     #
-    #     foo[bar] = value
-    #              ^
+    # foo[bar] = value
+    #          ^
+    # ```
     #
     # : () -> Location?
     def equal_loc: () -> Location?
@@ -2910,8 +3078,10 @@ module Prism
     #
     # Represents the block that is being passed to the method.
     #
-    #     foo { |a| a }
-    #         ^^^^^^^^^
+    # ```rb
+    # foo { |a| a }
+    #     ^^^^^^^^^
+    # ```
     #
     # : () -> (BlockNode | BlockArgumentNode)?
     def block: () -> (BlockNode | BlockArgumentNode)?
@@ -2962,8 +3132,10 @@ module Prism
 
   # Represents the use of an assignment operator on a call.
   #
-  #     foo.bar += baz
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^
+  # ```
   class CallOperatorWriteNode < Node
     @value: Prism::node
 
@@ -3063,8 +3235,10 @@ module Prism
     #
     # The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo.bar += value
-    #     ^^^
+    # ```rb
+    # foo.bar += value
+    # ^^^
+    # ```
     #
     # : () -> Prism::node?
     def receiver: () -> Prism::node?
@@ -3075,8 +3249,10 @@ module Prism
     #
     # Represents the Location of the call operator.
     #
-    #     foo.bar += value
-    #        ^
+    # ```rb
+    # foo.bar += value
+    #    ^
+    # ```
     #
     # : () -> Location?
     def call_operator_loc: () -> Location?
@@ -3094,8 +3270,10 @@ module Prism
     #
     # Represents the Location of the message.
     #
-    #     foo.bar += value
-    #         ^^^
+    # ```rb
+    # foo.bar += value
+    #     ^^^
+    # ```
     #
     # : () -> Location?
     def message_loc: () -> Location?
@@ -3112,8 +3290,10 @@ module Prism
     #
     # Represents the name of the method being called.
     #
-    #     foo.bar += value # read_name `:bar`
-    #         ^^^
+    # ```rb
+    # foo.bar += value # read_name `:bar`
+    #     ^^^
+    # ```
     #
     # : () -> Symbol
     def read_name: () -> Symbol
@@ -3123,8 +3303,10 @@ module Prism
     #
     # Represents the name of the method being written to.
     #
-    #     foo.bar += value # write_name `:bar=`
-    #         ^^^
+    # ```rb
+    # foo.bar += value # write_name `:bar=`
+    #     ^^^
+    # ```
     #
     # : () -> Symbol
     def write_name: () -> Symbol
@@ -3134,8 +3316,10 @@ module Prism
     #
     # Represents the binary operator being used.
     #
-    #     foo.bar += value # binary_operator `:+`
-    #             ^
+    # ```rb
+    # foo.bar += value # binary_operator `:+`
+    #         ^
+    # ```
     #
     # : () -> Symbol
     def binary_operator: () -> Symbol
@@ -3146,8 +3330,10 @@ module Prism
     #
     # Represents the Location of the binary operator.
     #
-    #     foo.bar += value
-    #             ^^
+    # ```rb
+    # foo.bar += value
+    #         ^^
+    # ```
     #
     # : () -> Location
     def binary_operator_loc: () -> Location
@@ -3164,8 +3350,10 @@ module Prism
     #
     # Represents the value being assigned.
     #
-    #     foo.bar += value
-    #                ^^^^^
+    # ```rb
+    # foo.bar += value
+    #            ^^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -3192,8 +3380,10 @@ module Prism
 
   # Represents the use of the `||=` operator on a call.
   #
-  #     foo.bar ||= value
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # foo.bar ||= value
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class CallOrWriteNode < Node
     @value: Prism::node
 
@@ -3291,8 +3481,10 @@ module Prism
     #
     # The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo.bar ||= value
-    #     ^^^
+    # ```rb
+    # foo.bar ||= value
+    # ^^^
+    # ```
     #
     # : () -> Prism::node?
     def receiver: () -> Prism::node?
@@ -3303,8 +3495,10 @@ module Prism
     #
     # Represents the Location of the call operator.
     #
-    #     foo.bar ||= value
-    #        ^
+    # ```rb
+    # foo.bar ||= value
+    #    ^
+    # ```
     #
     # : () -> Location?
     def call_operator_loc: () -> Location?
@@ -3322,8 +3516,10 @@ module Prism
     #
     # Represents the Location of the message.
     #
-    #     foo.bar ||= value
-    #         ^^^
+    # ```rb
+    # foo.bar ||= value
+    #     ^^^
+    # ```
     #
     # : () -> Location?
     def message_loc: () -> Location?
@@ -3340,8 +3536,10 @@ module Prism
     #
     # Represents the name of the method being called.
     #
-    #     foo.bar ||= value # read_name `:bar`
-    #         ^^^
+    # ```rb
+    # foo.bar ||= value # read_name `:bar`
+    #     ^^^
+    # ```
     #
     # : () -> Symbol
     def read_name: () -> Symbol
@@ -3351,8 +3549,10 @@ module Prism
     #
     # Represents the name of the method being written to.
     #
-    #     foo.bar ||= value # write_name `:bar=`
-    #         ^^^
+    # ```rb
+    # foo.bar ||= value # write_name `:bar=`
+    #     ^^^
+    # ```
     #
     # : () -> Symbol
     def write_name: () -> Symbol
@@ -3363,8 +3563,10 @@ module Prism
     #
     # Represents the Location of the operator.
     #
-    #     foo.bar ||= value
-    #             ^^^
+    # ```rb
+    # foo.bar ||= value
+    #         ^^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -3381,8 +3583,10 @@ module Prism
     #
     # Represents the value being assigned.
     #
-    #     foo.bar ||= value
-    #                 ^^^^^
+    # ```rb
+    # foo.bar ||= value
+    #             ^^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -3417,16 +3621,18 @@ module Prism
 
   # Represents assigning to a method call.
   #
-  #     foo.bar, = 1
-  #     ^^^^^^^
+  # ```rb
+  # foo.bar, = 1
+  # ^^^^^^^
   #
-  #     begin
-  #     rescue => foo.bar
-  #               ^^^^^^^
-  #     end
+  # begin
+  # rescue => foo.bar
+  #           ^^^^^^^
+  # end
   #
-  #     for foo.bar in baz do end
-  #         ^^^^^^^
+  # for foo.bar in baz do end
+  #     ^^^^^^^
+  # ```
   class CallTargetNode < Node
     @message_loc: Location
 
@@ -3518,8 +3724,10 @@ module Prism
     #
     # The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo.bar = 1
-    #     ^^^
+    # ```rb
+    # foo.bar = 1
+    # ^^^
+    # ```
     #
     # : () -> Prism::node
     def receiver: () -> Prism::node
@@ -3530,8 +3738,10 @@ module Prism
     #
     # Represents the Location of the call operator.
     #
-    #     foo.bar = 1
-    #        ^
+    # ```rb
+    # foo.bar = 1
+    #    ^
+    # ```
     #
     # : () -> Location
     def call_operator_loc: () -> Location
@@ -3548,8 +3758,10 @@ module Prism
     #
     # Represents the name of the method being called.
     #
-    #     foo.bar = 1 # name `:foo`
-    #     ^^^
+    # ```rb
+    # foo.bar = 1 # name `:foo`
+    # ^^^
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -3560,8 +3772,10 @@ module Prism
     #
     # Represents the Location of the message.
     #
-    #     foo.bar = 1
-    #         ^^^
+    # ```rb
+    # foo.bar = 1
+    #     ^^^
+    # ```
     #
     # : () -> Location
     def message_loc: () -> Location
@@ -3595,8 +3809,10 @@ module Prism
 
   # Represents assigning to a local variable in pattern matching.
   #
-  #     foo => [bar => baz]
-  #             ^^^^^^^^^^
+  # ```rb
+  # foo => [bar => baz]
+  #         ^^^^^^^^^^
+  # ```
   class CapturePatternNode < Node
     @operator_loc: Location
 
@@ -3662,8 +3878,10 @@ module Prism
     #
     # Represents the value to capture.
     #
-    #     foo => bar
-    #            ^^^
+    # ```rb
+    # foo => bar
+    #        ^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -3673,8 +3891,10 @@ module Prism
     #
     # Represents the target of the capture.
     #
-    #     foo => bar
-    #     ^^^
+    # ```rb
+    # foo => bar
+    # ^^^
+    # ```
     #
     # : () -> LocalVariableTargetNode
     def target: () -> LocalVariableTargetNode
@@ -3685,8 +3905,10 @@ module Prism
     #
     # Represents the Location of the `=>` operator.
     #
-    #     foo => bar
-    #         ^^
+    # ```rb
+    # foo => bar
+    #     ^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -3712,10 +3934,12 @@ module Prism
 
   # Represents the use of a case statement for pattern matching.
   #
-  #     case true
-  #     in false
-  #     end
-  #     ^^^^^^^^^
+  # ```rb
+  # case true
+  # in false
+  # end
+  # ^^^^^^^^^
+  # ```
   class CaseMatchNode < Node
     @end_keyword_loc: Location
 
@@ -3785,8 +4009,10 @@ module Prism
     #
     # Represents the predicate of the case match. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     case true; in false; end
-    #          ^^^^
+    # ```rb
+    # case true; in false; end
+    #      ^^^^
+    # ```
     #
     # : () -> Prism::node?
     def predicate: () -> Prism::node?
@@ -3796,8 +4022,10 @@ module Prism
     #
     # Represents the conditions of the case match.
     #
-    #     case true; in false; end
-    #                ^^^^^^^^
+    # ```rb
+    # case true; in false; end
+    #            ^^^^^^^^
+    # ```
     #
     # : () -> Array[InNode]
     def conditions: () -> Array[InNode]
@@ -3807,8 +4035,10 @@ module Prism
     #
     # Represents the else clause of the case match.
     #
-    #     case true; in false; else; end
-    #                          ^^^^^^^^^
+    # ```rb
+    # case true; in false; else; end
+    #                      ^^^^^^^^^
+    # ```
     #
     # : () -> ElseNode?
     def else_clause: () -> ElseNode?
@@ -3819,8 +4049,10 @@ module Prism
     #
     # Represents the Location of the `case` keyword.
     #
-    #     case true; in false; end
-    #     ^^^^
+    # ```rb
+    # case true; in false; end
+    # ^^^^
+    # ```
     #
     # : () -> Location
     def case_keyword_loc: () -> Location
@@ -3838,8 +4070,10 @@ module Prism
     #
     # Represents the Location of the `end` keyword.
     #
-    #     case true; in false; end
-    #                          ^^^
+    # ```rb
+    # case true; in false; end
+    #                      ^^^
+    # ```
     #
     # : () -> Location
     def end_keyword_loc: () -> Location
@@ -3873,10 +4107,12 @@ module Prism
 
   # Represents the use of a case statement.
   #
-  #     case true
-  #     when false
-  #     end
-  #     ^^^^^^^^^^
+  # ```rb
+  # case true
+  # when false
+  # end
+  # ^^^^^^^^^^
+  # ```
   class CaseNode < Node
     @end_keyword_loc: Location
 
@@ -3946,8 +4182,10 @@ module Prism
     #
     # Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     case true; when false; end
-    #          ^^^^
+    # ```rb
+    # case true; when false; end
+    #      ^^^^
+    # ```
     #
     # : () -> Prism::node?
     def predicate: () -> Prism::node?
@@ -3957,8 +4195,10 @@ module Prism
     #
     # Represents the conditions of the case statement.
     #
-    #     case true; when false; end
-    #                ^^^^^^^^^^
+    # ```rb
+    # case true; when false; end
+    #            ^^^^^^^^^^
+    # ```
     #
     # : () -> Array[WhenNode]
     def conditions: () -> Array[WhenNode]
@@ -3968,8 +4208,10 @@ module Prism
     #
     # Represents the else clause of the case statement.
     #
-    #     case true; when false; else; end
-    #                            ^^^^^^^^^
+    # ```rb
+    # case true; when false; else; end
+    #                        ^^^^^^^^^
+    # ```
     #
     # : () -> ElseNode?
     def else_clause: () -> ElseNode?
@@ -3980,8 +4222,10 @@ module Prism
     #
     # Represents the Location of the `case` keyword.
     #
-    #     case true; when false; end
-    #     ^^^^
+    # ```rb
+    # case true; when false; end
+    # ^^^^
+    # ```
     #
     # : () -> Location
     def case_keyword_loc: () -> Location
@@ -3999,8 +4243,10 @@ module Prism
     #
     # Represents the Location of the `end` keyword.
     #
-    #     case true; when false; end
-    #                            ^^^
+    # ```rb
+    # case true; when false; end
+    #                        ^^^
+    # ```
     #
     # : () -> Location
     def end_keyword_loc: () -> Location
@@ -4034,8 +4280,10 @@ module Prism
 
   # Represents a class declaration involving the `class` keyword.
   #
-  #     class Foo end
-  #     ^^^^^^^^^^^^^
+  # ```rb
+  # class Foo end
+  # ^^^^^^^^^^^^^
+  # ```
   class ClassNode < Node
     @name: Symbol
 
@@ -4120,8 +4368,10 @@ module Prism
     #
     # Represents the Location of the `class` keyword.
     #
-    #     class Foo end
-    #     ^^^^^
+    # ```rb
+    # class Foo end
+    # ^^^^^
+    # ```
     #
     # : () -> Location
     def class_keyword_loc: () -> Location
@@ -4147,8 +4397,10 @@ module Prism
     #
     # Represents the Location of the `<` operator.
     #
-    #     class Foo < Bar
-    #               ^
+    # ```rb
+    # class Foo < Bar
+    #           ^
+    # ```
     #
     # : () -> Location?
     def inheritance_operator_loc: () -> Location?
@@ -4165,8 +4417,10 @@ module Prism
     #
     # Represents the superclass of the class.
     #
-    #     class Foo < Bar
-    #                 ^^^
+    # ```rb
+    # class Foo < Bar
+    #             ^^^
+    # ```
     #
     # : () -> Prism::node?
     def superclass: () -> Prism::node?
@@ -4176,8 +4430,10 @@ module Prism
     #
     # Represents the body of the class.
     #
-    #     class Foo; bar; end
-    #                ^^^
+    # ```rb
+    # class Foo; bar; end
+    #            ^^^
+    # ```
     #
     # : () -> (StatementsNode | BeginNode)?
     def body: () -> (StatementsNode | BeginNode)?
@@ -4188,8 +4444,10 @@ module Prism
     #
     # Represents the Location of the `end` keyword.
     #
-    #     class Foo end
-    #               ^^^
+    # ```rb
+    # class Foo end
+    #           ^^^
+    # ```
     #
     # : () -> Location
     def end_keyword_loc: () -> Location
@@ -4206,7 +4464,9 @@ module Prism
     #
     # The name of the class.
     #
-    #     class Foo end # name `:Foo`
+    # ```rb
+    # class Foo end # name `:Foo`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -4241,8 +4501,10 @@ module Prism
 
   # Represents the use of the `&&=` operator for assignment to a class variable.
   #
-  #     @@target &&= value
-  #     ^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # @@target &&= value
+  # ^^^^^^^^^^^^^^^^^^
+  # ```
   class ClassVariableAndWriteNode < Node
     @value: Prism::node
 
@@ -4310,8 +4572,10 @@ module Prism
     #
     # The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
     #
-    #     @@target &&= value # name `:@@target`
-    #     ^^^^^^^^
+    # ```rb
+    # @@target &&= value # name `:@@target`
+    # ^^^^^^^^
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -4322,8 +4586,10 @@ module Prism
     #
     # Represents the Location of the variable name.
     #
-    #     @@target &&= value
-    #     ^^^^^^^^
+    # ```rb
+    # @@target &&= value
+    # ^^^^^^^^
+    # ```
     #
     # : () -> Location
     def name_loc: () -> Location
@@ -4341,8 +4607,10 @@ module Prism
     #
     # Represents the Location of the `&&=` operator.
     #
-    #     @@target &&= value
-    #              ^^^
+    # ```rb
+    # @@target &&= value
+    #          ^^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -4359,8 +4627,10 @@ module Prism
     #
     # Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     @@target &&= value
-    #                  ^^^^^
+    # ```rb
+    # @@target &&= value
+    #              ^^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -4379,8 +4649,10 @@ module Prism
 
   # Represents assigning to a class variable using an operator that isn't `=`.
   #
-  #     @@target += value
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # @@target += value
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class ClassVariableOperatorWriteNode < Node
     @binary_operator: Symbol
 
@@ -4507,8 +4779,10 @@ module Prism
 
   # Represents the use of the `||=` operator for assignment to a class variable.
   #
-  #     @@target ||= value
-  #     ^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # @@target ||= value
+  # ^^^^^^^^^^^^^^^^^^
+  # ```
   class ClassVariableOrWriteNode < Node
     @value: Prism::node
 
@@ -4633,8 +4907,10 @@ module Prism
 
   # Represents referencing a class variable.
   #
-  #     @@foo
-  #     ^^^^^
+  # ```rb
+  # @@foo
+  # ^^^^^
+  # ```
   class ClassVariableReadNode < Node
     @name: Symbol
 
@@ -4696,9 +4972,11 @@ module Prism
     #
     # The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
     #
-    #     @@abc   # name `:@@abc`
+    # ```rb
+    # @@abc   # name `:@@abc`
     #
-    #     @@_test # name `:@@_test`
+    # @@_test # name `:@@_test`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -4709,8 +4987,10 @@ module Prism
 
   # Represents writing to a class variable in a context that doesn't have an explicit value.
   #
-  #     @@foo, @@bar = baz
-  #     ^^^^^  ^^^^^
+  # ```rb
+  # @@foo, @@bar = baz
+  # ^^^^^  ^^^^^
+  # ```
   class ClassVariableTargetNode < Node
     @name: Symbol
 
@@ -4781,8 +5061,10 @@ module Prism
 
   # Represents writing to a class variable.
   #
-  #     @@foo = 1
-  #     ^^^^^^^^^
+  # ```rb
+  # @@foo = 1
+  # ^^^^^^^^^
+  # ```
   class ClassVariableWriteNode < Node
     @operator_loc: Location
 
@@ -4850,9 +5132,11 @@ module Prism
     #
     # The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
     #
-    #     @@abc = 123     # name `@@abc`
+    # ```rb
+    # @@abc = 123     # name `@@abc`
     #
-    #     @@_test = :test # name `@@_test`
+    # @@_test = :test # name `@@_test`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -4863,8 +5147,10 @@ module Prism
     #
     # The Location of the variable name.
     #
-    #     @@foo = :bar
-    #     ^^^^^
+    # ```rb
+    # @@foo = :bar
+    # ^^^^^
+    # ```
     #
     # : () -> Location
     def name_loc: () -> Location
@@ -4881,11 +5167,13 @@ module Prism
     #
     # The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     @@foo = :bar
-    #             ^^^^
+    # ```rb
+    # @@foo = :bar
+    #         ^^^^
     #
-    #     @@_xyz = 123
-    #              ^^^
+    # @@_xyz = 123
+    #          ^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -4896,8 +5184,10 @@ module Prism
     #
     # The Location of the `=` operator.
     #
-    #     @@foo = :bar
-    #           ^
+    # ```rb
+    # @@foo = :bar
+    #       ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -4923,8 +5213,10 @@ module Prism
 
   # Represents the use of the `&&=` operator for assignment to a constant.
   #
-  #     Target &&= value
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # Target &&= value
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class ConstantAndWriteNode < Node
     @value: Prism::node
 
@@ -5049,8 +5341,10 @@ module Prism
 
   # Represents assigning to a constant using an operator that isn't `=`.
   #
-  #     Target += value
-  #     ^^^^^^^^^^^^^^^
+  # ```rb
+  # Target += value
+  # ^^^^^^^^^^^^^^^
+  # ```
   class ConstantOperatorWriteNode < Node
     @binary_operator: Symbol
 
@@ -5177,8 +5471,10 @@ module Prism
 
   # Represents the use of the `||=` operator for assignment to a constant.
   #
-  #     Target ||= value
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # Target ||= value
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class ConstantOrWriteNode < Node
     @value: Prism::node
 
@@ -5303,8 +5599,10 @@ module Prism
 
   # Represents the use of the `&&=` operator for assignment to a constant path.
   #
-  #     Parent::Child &&= value
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # Parent::Child &&= value
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class ConstantPathAndWriteNode < Node
     @value: Prism::node
 
@@ -5411,8 +5709,10 @@ module Prism
 
   # Represents accessing a constant through a path of `::` operators.
   #
-  #     Foo::Bar
-  #     ^^^^^^^^
+  # ```rb
+  # Foo::Bar
+  # ^^^^^^^^
+  # ```
   class ConstantPathNode < Node
     @name_loc: Location
 
@@ -5480,14 +5780,16 @@ module Prism
     #
     # The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
     #
-    #     Foo::Bar
-    #     ^^^
+    # ```rb
+    # Foo::Bar
+    # ^^^
     #
-    #     self::Test
-    #     ^^^^
+    # self::Test
+    # ^^^^
     #
-    #     a.b::C
-    #     ^^^
+    # a.b::C
+    # ^^^
+    # ```
     #
     # : () -> Prism::node?
     def parent: () -> Prism::node?
@@ -5506,11 +5808,13 @@ module Prism
     #
     # The Location of the `::` delimiter.
     #
-    #     ::Foo
-    #     ^^
+    # ```rb
+    # ::Foo
+    # ^^
     #
-    #     One::Two
-    #        ^^
+    # One::Two
+    #    ^^
+    # ```
     #
     # : () -> Location
     def delimiter_loc: () -> Location
@@ -5528,11 +5832,13 @@ module Prism
     #
     # The Location of the name of the constant.
     #
-    #     ::Foo
-    #       ^^^
+    # ```rb
+    # ::Foo
+    #   ^^^
     #
-    #     One::Two
-    #          ^^^
+    # One::Two
+    #      ^^^
+    # ```
     #
     # : () -> Location
     def name_loc: () -> Location
@@ -5558,8 +5864,10 @@ module Prism
 
   # Represents assigning to a constant path using an operator that isn't `=`.
   #
-  #     Parent::Child += value
-  #     ^^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # Parent::Child += value
+  # ^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class ConstantPathOperatorWriteNode < Node
     @binary_operator: Symbol
 
@@ -5668,8 +5976,10 @@ module Prism
 
   # Represents the use of the `||=` operator for assignment to a constant path.
   #
-  #     Parent::Child ||= value
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # Parent::Child ||= value
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class ConstantPathOrWriteNode < Node
     @value: Prism::node
 
@@ -5776,8 +6086,10 @@ module Prism
 
   # Represents writing to a constant path in a context that doesn't have an explicit value.
   #
-  #     Foo::Foo, Bar::Bar = baz
-  #     ^^^^^^^^  ^^^^^^^^
+  # ```rb
+  # Foo::Foo, Bar::Bar = baz
+  # ^^^^^^^^  ^^^^^^^^
+  # ```
   class ConstantPathTargetNode < Node
     @name_loc: Location
 
@@ -5902,14 +6214,16 @@ module Prism
 
   # Represents writing to a constant path.
   #
-  #     ::Foo = 1
-  #     ^^^^^^^^^
+  # ```rb
+  # ::Foo = 1
+  # ^^^^^^^^^
   #
-  #     Foo::Bar = 1
-  #     ^^^^^^^^^^^^
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
   #
-  #     ::Foo::Bar = 1
-  #     ^^^^^^^^^^^^^^
+  # ::Foo::Bar = 1
+  # ^^^^^^^^^^^^^^
+  # ```
   class ConstantPathWriteNode < Node
     @value: Prism::node
 
@@ -5975,11 +6289,13 @@ module Prism
     #
     # A node representing the constant path being written to.
     #
-    #     Foo::Bar = 1
-    #     ^^^^^^^^
+    # ```rb
+    # Foo::Bar = 1
+    # ^^^^^^^^
     #
-    #     ::Foo = :abc
-    #     ^^^^^
+    # ::Foo = :abc
+    # ^^^^^
+    # ```
     #
     # : () -> ConstantPathNode
     def target: () -> ConstantPathNode
@@ -5990,8 +6306,10 @@ module Prism
     #
     # The Location of the `=` operator.
     #
-    #     ::ABC = 123
-    #           ^
+    # ```rb
+    # ::ABC = 123
+    #       ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -6008,8 +6326,10 @@ module Prism
     #
     # The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     FOO::BAR = :abc
-    #                ^^^^
+    # ```rb
+    # FOO::BAR = :abc
+    #            ^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -6028,8 +6348,10 @@ module Prism
 
   # Represents referencing a constant.
   #
-  #     Foo
-  #     ^^^
+  # ```rb
+  # Foo
+  # ^^^
+  # ```
   class ConstantReadNode < Node
     @name: Symbol
 
@@ -6091,9 +6413,11 @@ module Prism
     #
     # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
     #
-    #     X              # name `:X`
+    # ```rb
+    # X              # name `:X`
     #
-    #     SOME_CONSTANT  # name `:SOME_CONSTANT`
+    # SOME_CONSTANT  # name `:SOME_CONSTANT`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -6104,8 +6428,10 @@ module Prism
 
   # Represents writing to a constant in a context that doesn't have an explicit value.
   #
-  #     Foo, Bar = baz
-  #     ^^^  ^^^
+  # ```rb
+  # Foo, Bar = baz
+  # ^^^  ^^^
+  # ```
   class ConstantTargetNode < Node
     @name: Symbol
 
@@ -6176,8 +6502,10 @@ module Prism
 
   # Represents writing to a constant.
   #
-  #     Foo = 1
-  #     ^^^^^^^
+  # ```rb
+  # Foo = 1
+  # ^^^^^^^
+  # ```
   class ConstantWriteNode < Node
     @operator_loc: Location
 
@@ -6245,9 +6573,11 @@ module Prism
     #
     # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
     #
-    #     Foo = :bar # name `:Foo`
+    # ```rb
+    # Foo = :bar # name `:Foo`
     #
-    #     XYZ = 1    # name `:XYZ`
+    # XYZ = 1    # name `:XYZ`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -6258,8 +6588,10 @@ module Prism
     #
     # The Location of the constant name.
     #
-    #     FOO = 1
-    #     ^^^
+    # ```rb
+    # FOO = 1
+    # ^^^
+    # ```
     #
     # : () -> Location
     def name_loc: () -> Location
@@ -6276,11 +6608,13 @@ module Prism
     #
     # The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     FOO = :bar
-    #           ^^^^
+    # ```rb
+    # FOO = :bar
+    #       ^^^^
     #
-    #     MyClass = Class.new
-    #               ^^^^^^^^^
+    # MyClass = Class.new
+    #           ^^^^^^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -6291,8 +6625,10 @@ module Prism
     #
     # The Location of the `=` operator.
     #
-    #     FOO = :bar
-    #         ^
+    # ```rb
+    # FOO = :bar
+    #     ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -6318,9 +6654,11 @@ module Prism
 
   # Represents a method definition.
   #
-  #     def method
-  #     end
-  #     ^^^^^^^^^^
+  # ```rb
+  # def method
+  # end
+  # ^^^^^^^^^^
+  # ```
   class DefNode < Node
     @end_keyword_loc: Location?
 
@@ -6605,8 +6943,10 @@ module Prism
 
   # Represents the use of the `defined?` keyword.
   #
-  #     defined?(a)
-  #     ^^^^^^^^^^^
+  # ```rb
+  # defined?(a)
+  # ^^^^^^^^^^^
+  # ```
   class DefinedNode < Node
     @keyword_loc: Location
 
@@ -6755,8 +7095,10 @@ module Prism
 
   # Represents an `else` clause in a `case`, `if`, or `unless` statement.
   #
-  #     if a then b else c end
-  #                 ^^^^^^^^^^
+  # ```rb
+  # if a then b else c end
+  #             ^^^^^^^^^^
+  # ```
   class ElseNode < Node
     @end_keyword_loc: Location?
 
@@ -6879,8 +7221,10 @@ module Prism
 
   # Represents an interpolated set of statements.
   #
-  #     "foo #{bar}"
-  #          ^^^^^^
+  # ```rb
+  # "foo #{bar}"
+  #      ^^^^^^
+  # ```
   class EmbeddedStatementsNode < Node
     @closing_loc: Location
 
@@ -7003,8 +7347,10 @@ module Prism
 
   # Represents an interpolated variable.
   #
-  #     "foo #@bar"
-  #          ^^^^^
+  # ```rb
+  # "foo #@bar"
+  #      ^^^^^
+  # ```
   class EmbeddedVariableNode < Node
     @variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode
 
@@ -7101,12 +7447,14 @@ module Prism
 
   # Represents an `ensure` clause in a `begin` statement.
   #
-  #     begin
-  #       foo
-  #     ensure
-  #     ^^^^^^
-  #       bar
-  #     end
+  # ```rb
+  # begin
+  #   foo
+  # ensure
+  # ^^^^^^
+  #   bar
+  # end
+  # ```
   class EnsureNode < Node
     @end_keyword_loc: Location
 
@@ -7298,8 +7646,10 @@ module Prism
 
   # Represents the use of the literal `false` keyword.
   #
-  #     false
-  #     ^^^^^
+  # ```rb
+  # false
+  # ^^^^^
+  # ```
   class FalseNode < Node
     # Initialize a new FalseNode node.
     #
@@ -7360,17 +7710,19 @@ module Prism
 
   # Represents a find pattern in pattern matching.
   #
-  #     foo in *bar, baz, *qux
-  #            ^^^^^^^^^^^^^^^
+  # ```rb
+  # foo in *bar, baz, *qux
+  #        ^^^^^^^^^^^^^^^
   #
-  #     foo in [*bar, baz, *qux]
-  #            ^^^^^^^^^^^^^^^^^
+  # foo in [*bar, baz, *qux]
+  #        ^^^^^^^^^^^^^^^^^
   #
-  #     foo in Foo(*bar, baz, *qux)
-  #            ^^^^^^^^^^^^^^^^^^^^
+  # foo in Foo(*bar, baz, *qux)
+  #        ^^^^^^^^^^^^^^^^^^^^
   #
-  #     foo => *bar, baz, *qux
-  #            ^^^^^^^^^^^^^^^
+  # foo => *bar, baz, *qux
+  #        ^^^^^^^^^^^^^^^
+  # ```
   class FindPatternNode < Node
     @closing_loc: Location?
 
@@ -7442,8 +7794,10 @@ module Prism
     #
     # Represents the optional constant preceding the pattern
     #
-    #     foo in Foo(*bar, baz, *qux)
-    #            ^^^
+    # ```rb
+    # foo in Foo(*bar, baz, *qux)
+    #        ^^^
+    # ```
     #
     # : () -> (ConstantPathNode | ConstantReadNode)?
     def constant: () -> (ConstantPathNode | ConstantReadNode)?
@@ -7453,11 +7807,13 @@ module Prism
     #
     # Represents the first wildcard node in the pattern.
     #
-    #     foo in *bar, baz, *qux
-    #            ^^^^
+    # ```rb
+    # foo in *bar, baz, *qux
+    #        ^^^^
     #
-    #     foo in Foo(*bar, baz, *qux)
-    #                ^^^^
+    # foo in Foo(*bar, baz, *qux)
+    #            ^^^^
+    # ```
     #
     # : () -> SplatNode
     def left: () -> SplatNode
@@ -7467,11 +7823,13 @@ module Prism
     #
     # Represents the nodes in between the wildcards.
     #
-    #     foo in *bar, baz, *qux
-    #                  ^^^
+    # ```rb
+    # foo in *bar, baz, *qux
+    #              ^^^
     #
-    #     foo in Foo(*bar, baz, 1, *qux)
-    #                      ^^^^^^
+    # foo in Foo(*bar, baz, 1, *qux)
+    #                  ^^^^^^
+    # ```
     #
     # : () -> Array[Prism::node]
     def requireds: () -> Array[Prism::node]
@@ -7481,11 +7839,13 @@ module Prism
     #
     # Represents the second wildcard node in the pattern.
     #
-    #     foo in *bar, baz, *qux
-    #                       ^^^^
+    # ```rb
+    # foo in *bar, baz, *qux
+    #                   ^^^^
     #
-    #     foo in Foo(*bar, baz, *qux)
-    #                           ^^^^
+    # foo in Foo(*bar, baz, *qux)
+    #                       ^^^^
+    # ```
     #
     # : () -> SplatNode
     def right: () -> SplatNode
@@ -7496,11 +7856,13 @@ module Prism
     #
     # The Location of the opening brace.
     #
-    #     foo in [*bar, baz, *qux]
-    #            ^
+    # ```rb
+    # foo in [*bar, baz, *qux]
+    #        ^
     #
-    #     foo in Foo(*bar, baz, *qux)
-    #               ^
+    # foo in Foo(*bar, baz, *qux)
+    #           ^
+    # ```
     #
     # : () -> Location?
     def opening_loc: () -> Location?
@@ -7518,11 +7880,13 @@ module Prism
     #
     # The Location of the closing brace.
     #
-    #     foo in [*bar, baz, *qux]
-    #                            ^
+    # ```rb
+    # foo in [*bar, baz, *qux]
+    #                        ^
     #
-    #     foo in Foo(*bar, baz, *qux)
-    #                               ^
+    # foo in Foo(*bar, baz, *qux)
+    #                           ^
+    # ```
     #
     # : () -> Location?
     def closing_loc: () -> Location?
@@ -7556,8 +7920,10 @@ module Prism
 
   # Represents the use of the `..` or `...` operators to create flip flops.
   #
-  #     baz if foo .. bar
-  #            ^^^^^^^^^^
+  # ```rb
+  # baz if foo .. bar
+  #        ^^^^^^^^^^
+  # ```
   class FlipFlopNode < Node
     @operator_loc: Location
 
@@ -7670,8 +8036,10 @@ module Prism
 
   # Represents a floating point number literal.
   #
-  #     1.0
-  #     ^^^
+  # ```rb
+  # 1.0
+  # ^^^
+  # ```
   class FloatNode < Node
     @value: Float
 
@@ -7742,8 +8110,10 @@ module Prism
 
   # Represents the use of the `for` keyword.
   #
-  #     for i in a end
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # for i in a end
+  # ^^^^^^^^^^^^^^
+  # ```
   class ForNode < Node
     @end_keyword_loc: Location
 
@@ -7817,8 +8187,10 @@ module Prism
     #
     # The index expression for `for` loops.
     #
-    #     for i in a end
-    #         ^
+    # ```rb
+    # for i in a end
+    #     ^
+    # ```
     #
     # : () -> (LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode)
     def index: () -> (LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode)
@@ -7828,8 +8200,10 @@ module Prism
     #
     # The collection to iterate over.
     #
-    #     for i in a end
-    #              ^
+    # ```rb
+    # for i in a end
+    #          ^
+    # ```
     #
     # : () -> Prism::node
     def collection: () -> Prism::node
@@ -7839,10 +8213,12 @@ module Prism
     #
     # Represents the body of statements to execute for each iteration of the loop.
     #
-    #     for i in a
-    #       foo(i)
-    #       ^^^^^^
-    #     end
+    # ```rb
+    # for i in a
+    #   foo(i)
+    #   ^^^^^^
+    # end
+    # ```
     #
     # : () -> StatementsNode?
     def statements: () -> StatementsNode?
@@ -7853,8 +8229,10 @@ module Prism
     #
     # The Location of the `for` keyword.
     #
-    #     for i in a end
-    #     ^^^
+    # ```rb
+    # for i in a end
+    # ^^^
+    # ```
     #
     # : () -> Location
     def for_keyword_loc: () -> Location
@@ -7872,8 +8250,10 @@ module Prism
     #
     # The Location of the `in` keyword.
     #
-    #     for i in a end
-    #           ^^
+    # ```rb
+    # for i in a end
+    #       ^^
+    # ```
     #
     # : () -> Location
     def in_keyword_loc: () -> Location
@@ -7891,8 +8271,10 @@ module Prism
     #
     # The Location of the `do` keyword, if present.
     #
-    #     for i in a do end
-    #                ^^
+    # ```rb
+    # for i in a do end
+    #            ^^
+    # ```
     #
     # : () -> Location?
     def do_keyword_loc: () -> Location?
@@ -7910,8 +8292,10 @@ module Prism
     #
     # The Location of the `end` keyword.
     #
-    #     for i in a end
-    #                ^^^
+    # ```rb
+    # for i in a end
+    #            ^^^
+    # ```
     #
     # : () -> Location
     def end_keyword_loc: () -> Location
@@ -7961,10 +8345,12 @@ module Prism
 
   # Represents forwarding all arguments to this method to another method.
   #
-  #     def foo(...)
-  #       bar(...)
-  #           ^^^
-  #     end
+  # ```rb
+  # def foo(...)
+  #   bar(...)
+  #       ^^^
+  # end
+  # ```
   class ForwardingArgumentsNode < Node
     # Initialize a new ForwardingArgumentsNode node.
     #
@@ -8025,9 +8411,11 @@ module Prism
 
   # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
   #
-  #     def foo(...)
-  #             ^^^
-  #     end
+  # ```rb
+  # def foo(...)
+  #         ^^^
+  # end
+  # ```
   class ForwardingParameterNode < Node
     # Initialize a new ForwardingParameterNode node.
     #
@@ -8088,12 +8476,14 @@ module Prism
 
   # Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.
   #
-  #     super
-  #     ^^^^^
+  # ```rb
+  # super
+  # ^^^^^
   #
-  #     super { 123 }
-  #     ^^^^^^^^^^^^^
+  # super { 123 }
+  # ^^^^^^^^^^^^^
   #
+  # ```
   # If it has any other arguments, it would be a `SuperNode` instead.
   class ForwardingSuperNode < Node
     @block: BlockNode?
@@ -8195,8 +8585,10 @@ module Prism
 
   # Represents the use of the `&&=` operator for assignment to a global variable.
   #
-  #     $target &&= value
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # $target &&= value
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class GlobalVariableAndWriteNode < Node
     @value: Prism::node
 
@@ -8321,8 +8713,10 @@ module Prism
 
   # Represents assigning to a global variable using an operator that isn't `=`.
   #
-  #     $target += value
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # $target += value
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class GlobalVariableOperatorWriteNode < Node
     @binary_operator: Symbol
 
@@ -8449,8 +8843,10 @@ module Prism
 
   # Represents the use of the `||=` operator for assignment to a global variable.
   #
-  #     $target ||= value
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # $target ||= value
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class GlobalVariableOrWriteNode < Node
     @value: Prism::node
 
@@ -8575,8 +8971,10 @@ module Prism
 
   # Represents referencing a global variable.
   #
-  #     $foo
-  #     ^^^^
+  # ```rb
+  # $foo
+  # ^^^^
+  # ```
   class GlobalVariableReadNode < Node
     @name: Symbol
 
@@ -8638,9 +9036,11 @@ module Prism
     #
     # The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
     #
-    #     $foo   # name `:$foo`
+    # ```rb
+    # $foo   # name `:$foo`
     #
-    #     $_Test # name `:$_Test`
+    # $_Test # name `:$_Test`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -8651,8 +9051,10 @@ module Prism
 
   # Represents writing to a global variable in a context that doesn't have an explicit value.
   #
-  #     $foo, $bar = baz
-  #     ^^^^  ^^^^
+  # ```rb
+  # $foo, $bar = baz
+  # ^^^^  ^^^^
+  # ```
   class GlobalVariableTargetNode < Node
     @name: Symbol
 
@@ -8723,8 +9125,10 @@ module Prism
 
   # Represents writing to a global variable.
   #
-  #     $foo = 1
-  #     ^^^^^^^^
+  # ```rb
+  # $foo = 1
+  # ^^^^^^^^
+  # ```
   class GlobalVariableWriteNode < Node
     @operator_loc: Location
 
@@ -8792,9 +9196,11 @@ module Prism
     #
     # The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
     #
-    #     $foo = :bar  # name `:$foo`
+    # ```rb
+    # $foo = :bar  # name `:$foo`
     #
-    #     $_Test = 123 # name `:$_Test`
+    # $_Test = 123 # name `:$_Test`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -8805,8 +9211,10 @@ module Prism
     #
     # The Location of the global variable's name.
     #
-    #     $foo = :bar
-    #     ^^^^
+    # ```rb
+    # $foo = :bar
+    # ^^^^
+    # ```
     #
     # : () -> Location
     def name_loc: () -> Location
@@ -8823,11 +9231,13 @@ module Prism
     #
     # The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     $foo = :bar
-    #            ^^^^
+    # ```rb
+    # $foo = :bar
+    #        ^^^^
     #
-    #     $-xyz = 123
-    #             ^^^
+    # $-xyz = 123
+    #         ^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -8838,8 +9248,10 @@ module Prism
     #
     # The Location of the `=` operator.
     #
-    #     $foo = :bar
-    #          ^
+    # ```rb
+    # $foo = :bar
+    #      ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -8865,8 +9277,10 @@ module Prism
 
   # Represents a hash literal.
   #
-  #     { a => b }
-  #     ^^^^^^^^^^
+  # ```rb
+  # { a => b }
+  # ^^^^^^^^^^
+  # ```
   class HashNode < Node
     @closing_loc: Location
 
@@ -8933,8 +9347,10 @@ module Prism
     #
     # The Location of the opening brace.
     #
-    #     { a => b }
-    #     ^
+    # ```rb
+    # { a => b }
+    # ^
+    # ```
     #
     # : () -> Location
     def opening_loc: () -> Location
@@ -8951,11 +9367,13 @@ module Prism
     #
     # The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
     #
-    #     { a: b }
-    #       ^^^^
+    # ```rb
+    # { a: b }
+    #   ^^^^
     #
-    #     { **foo }
-    #       ^^^^^
+    # { **foo }
+    #   ^^^^^
+    # ```
     #
     # : () -> Array[AssocNode | AssocSplatNode]
     def elements: () -> Array[AssocNode | AssocSplatNode]
@@ -8966,8 +9384,10 @@ module Prism
     #
     # The Location of the closing brace.
     #
-    #     { a => b }
-    #              ^
+    # ```rb
+    # { a => b }
+    #          ^
+    # ```
     #
     # : () -> Location
     def closing_loc: () -> Location
@@ -9001,17 +9421,19 @@ module Prism
 
   # Represents a hash pattern in pattern matching.
   #
-  #     foo => { a: 1, b: 2 }
-  #            ^^^^^^^^^^^^^^
+  # ```rb
+  # foo => { a: 1, b: 2 }
+  #        ^^^^^^^^^^^^^^
   #
-  #     foo => { a: 1, b: 2, **c }
-  #            ^^^^^^^^^^^^^^^^^^^
+  # foo => { a: 1, b: 2, **c }
+  #        ^^^^^^^^^^^^^^^^^^^
   #
-  #     foo => Bar[a: 1, b: 2]
-  #            ^^^^^^^^^^^^^^^
+  # foo => Bar[a: 1, b: 2]
+  #        ^^^^^^^^^^^^^^^
   #
-  #     foo in { a: 1, b: 2 }
-  #            ^^^^^^^^^^^^^^
+  # foo in { a: 1, b: 2 }
+  #        ^^^^^^^^^^^^^^
+  # ```
   class HashPatternNode < Node
     @closing_loc: Location?
 
@@ -9081,11 +9503,13 @@ module Prism
     #
     # Represents the optional constant preceding the Hash.
     #
-    #     foo => Bar[a: 1, b: 2]
-    #          ^^^
+    # ```rb
+    # foo => Bar[a: 1, b: 2]
+    #      ^^^
     #
-    #     foo => Bar::Baz[a: 1, b: 2]
-    #          ^^^^^^^^
+    # foo => Bar::Baz[a: 1, b: 2]
+    #      ^^^^^^^^
+    # ```
     #
     # : () -> (ConstantPathNode | ConstantReadNode)?
     def constant: () -> (ConstantPathNode | ConstantReadNode)?
@@ -9095,8 +9519,10 @@ module Prism
     #
     # Represents the explicit named hash keys and values.
     #
-    #     foo => { a: 1, b:, ** }
-    #              ^^^^^^^^
+    # ```rb
+    # foo => { a: 1, b:, ** }
+    #          ^^^^^^^^
+    # ```
     #
     # : () -> Array[AssocNode]
     def elements: () -> Array[AssocNode]
@@ -9106,14 +9532,16 @@ module Prism
     #
     # Represents the rest of the Hash keys and values. This can be named, unnamed, or explicitly forbidden via `**nil`, this last one results in a `NoKeywordsParameterNode`.
     #
-    #     foo => { a: 1, b:, **c }
-    #                        ^^^
+    # ```rb
+    # foo => { a: 1, b:, **c }
+    #                    ^^^
     #
-    #     foo => { a: 1, b:, ** }
-    #                        ^^
+    # foo => { a: 1, b:, ** }
+    #                    ^^
     #
-    #     foo => { a: 1, b:, **nil }
-    #                        ^^^^^
+    # foo => { a: 1, b:, **nil }
+    #                    ^^^^^
+    # ```
     #
     # : () -> (AssocSplatNode | NoKeywordsParameterNode)?
     def rest: () -> (AssocSplatNode | NoKeywordsParameterNode)?
@@ -9124,11 +9552,13 @@ module Prism
     #
     # The Location of the opening brace.
     #
-    #     foo => { a: 1 }
-    #            ^
+    # ```rb
+    # foo => { a: 1 }
+    #        ^
     #
-    #     foo => Bar[a: 1]
-    #               ^
+    # foo => Bar[a: 1]
+    #           ^
+    # ```
     #
     # : () -> Location?
     def opening_loc: () -> Location?
@@ -9146,11 +9576,13 @@ module Prism
     #
     # The Location of the closing brace.
     #
-    #     foo => { a: 1 }
-    #                   ^
+    # ```rb
+    # foo => { a: 1 }
+    #               ^
     #
-    #     foo => Bar[a: 1]
-    #                    ^
+    # foo => Bar[a: 1]
+    #                ^
+    # ```
     #
     # : () -> Location?
     def closing_loc: () -> Location?
@@ -9184,14 +9616,16 @@ module Prism
 
   # Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
   #
-  #     bar if foo
-  #     ^^^^^^^^^^
+  # ```rb
+  # bar if foo
+  # ^^^^^^^^^^
   #
-  #     if foo then bar end
-  #     ^^^^^^^^^^^^^^^^^^^
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
   #
-  #     foo ? bar : baz
-  #     ^^^^^^^^^^^^^^^
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  # ```
   class IfNode < Node
     @end_keyword_loc: Location?
 
@@ -9264,9 +9698,11 @@ module Prism
     #
     # The Location of the `if` keyword if present.
     #
-    #     bar if foo
-    #         ^^
+    # ```rb
+    # bar if foo
+    #     ^^
     #
+    # ```
     # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
     #
     # : () -> Location?
@@ -9284,16 +9720,18 @@ module Prism
     #
     # The node for the condition the `IfNode` is testing.
     #
-    #     if foo
-    #        ^^^
-    #       bar
-    #     end
+    # ```rb
+    # if foo
+    #    ^^^
+    #   bar
+    # end
     #
-    #     bar if foo
-    #            ^^^
+    # bar if foo
+    #        ^^^
     #
-    #     foo ? bar : baz
-    #     ^^^
+    # foo ? bar : baz
+    # ^^^
+    # ```
     #
     # : () -> Prism::node
     def predicate: () -> Prism::node
@@ -9304,11 +9742,13 @@ module Prism
     #
     # The Location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
     #
-    #     if foo then bar end
-    #            ^^^^
+    # ```rb
+    # if foo then bar end
+    #        ^^^^
     #
-    #     a ? b : c
-    #       ^
+    # a ? b : c
+    #   ^
+    # ```
     #
     # : () -> Location?
     def then_keyword_loc: () -> Location?
@@ -9325,12 +9765,14 @@ module Prism
     #
     # Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
     #
-    #     if foo
-    #       bar
-    #       ^^^
-    #       baz
-    #       ^^^
-    #     end
+    # ```rb
+    # if foo
+    #   bar
+    #   ^^^
+    #   baz
+    #   ^^^
+    # end
+    # ```
     #
     # : () -> StatementsNode?
     def statements: () -> StatementsNode?
@@ -9340,17 +9782,19 @@ module Prism
     #
     # Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
     #
-    #     if foo
-    #       bar
-    #     elsif baz
-    #     ^^^^^^^^^
-    #       qux
-    #       ^^^
-    #     end
-    #     ^^^
+    # ```rb
+    # if foo
+    #   bar
+    # elsif baz
+    # ^^^^^^^^^
+    #   qux
+    #   ^^^
+    # end
+    # ^^^
     #
-    #     if foo then bar else baz end
-    #                     ^^^^^^^^^^^^
+    # if foo then bar else baz end
+    #                 ^^^^^^^^^^^^
+    # ```
     #
     # : () -> (ElseNode | IfNode)?
     def subsequent: () -> (ElseNode | IfNode)?
@@ -9361,10 +9805,12 @@ module Prism
     #
     # The Location of the `end` keyword if present, `nil` otherwise.
     #
-    #     if foo
-    #       bar
-    #     end
-    #     ^^^
+    # ```rb
+    # if foo
+    #   bar
+    # end
+    # ^^^
+    # ```
     #
     # : () -> Location?
     def end_keyword_loc: () -> Location?
@@ -9406,8 +9852,10 @@ module Prism
 
   # Represents an imaginary number literal.
   #
-  #     1.0i
-  #     ^^^^
+  # ```rb
+  # 1.0i
+  # ^^^^
+  # ```
   class ImaginaryNode < Node
     @numeric: FloatNode | IntegerNode | RationalNode
 
@@ -9478,14 +9926,16 @@ module Prism
 
   # Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
   #
-  #     { foo: }
-  #       ^^^^
+  # ```rb
+  # { foo: }
+  #   ^^^^
   #
-  #     { Foo: }
-  #       ^^^^
+  # { Foo: }
+  #   ^^^^
   #
-  #     foo in { bar: }
-  #              ^^^^
+  # foo in { bar: }
+  #          ^^^^
+  # ```
   class ImplicitNode < Node
     @value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode
 
@@ -9556,17 +10006,19 @@ module Prism
 
   # Represents using a trailing comma to indicate an implicit rest parameter.
   #
-  #     foo { |bar,| }
-  #               ^
-  #
-  #     foo in [bar,]
-  #                ^
+  # ```rb
+  # foo { |bar,| }
+  #           ^
   #
-  #     for foo, in bar do end
+  # foo in [bar,]
   #            ^
   #
-  #     foo, = bar
+  # for foo, in bar do end
   #        ^
+  #
+  # foo, = bar
+  #    ^
+  # ```
   class ImplicitRestNode < Node
     # Initialize a new ImplicitRestNode node.
     #
@@ -9627,8 +10079,10 @@ module Prism
 
   # Represents the use of the `in` keyword in a case statement.
   #
-  #     case a; in b then c end
-  #             ^^^^^^^^^^^
+  # ```rb
+  # case a; in b then c end
+  #         ^^^^^^^^^^^
+  # ```
   class InNode < Node
     @then_keyword_loc: Location?
 
@@ -9761,8 +10215,10 @@ module Prism
 
   # Represents the use of the `&&=` operator on a call to the `[]` method.
   #
-  #     foo.bar[baz] &&= value
-  #     ^^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # foo.bar[baz] &&= value
+  # ^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class IndexAndWriteNode < Node
     @value: Prism::node
 
@@ -9991,8 +10447,10 @@ module Prism
 
   # Represents the use of an assignment operator on a call to `[]`.
   #
-  #     foo.bar[baz] += value
-  #     ^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # foo.bar[baz] += value
+  # ^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class IndexOperatorWriteNode < Node
     @value: Prism::node
 
@@ -10223,8 +10681,10 @@ module Prism
 
   # Represents the use of the `||=` operator on a call to `[]`.
   #
-  #     foo.bar[baz] ||= value
-  #     ^^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # foo.bar[baz] ||= value
+  # ^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class IndexOrWriteNode < Node
     @value: Prism::node
 
@@ -10453,16 +10913,18 @@ module Prism
 
   # Represents assigning to an index.
   #
-  #     foo[bar], = 1
-  #     ^^^^^^^^
+  # ```rb
+  # foo[bar], = 1
+  # ^^^^^^^^
   #
-  #     begin
-  #     rescue => foo[bar]
-  #               ^^^^^^^^
-  #     end
+  # begin
+  # rescue => foo[bar]
+  #           ^^^^^^^^
+  # end
   #
-  #     for foo[bar] in baz do end
-  #         ^^^^^^^^
+  # for foo[bar] in baz do end
+  #     ^^^^^^^^
+  # ```
   class IndexTargetNode < Node
     @block: BlockArgumentNode?
 
@@ -10629,8 +11091,10 @@ module Prism
 
   # Represents the use of the `&&=` operator for assignment to an instance variable.
   #
-  #     @target &&= value
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # @target &&= value
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class InstanceVariableAndWriteNode < Node
     @value: Prism::node
 
@@ -10755,8 +11219,10 @@ module Prism
 
   # Represents assigning to an instance variable using an operator that isn't `=`.
   #
-  #     @target += value
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # @target += value
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class InstanceVariableOperatorWriteNode < Node
     @binary_operator: Symbol
 
@@ -10883,8 +11349,10 @@ module Prism
 
   # Represents the use of the `||=` operator for assignment to an instance variable.
   #
-  #     @target ||= value
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # @target ||= value
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class InstanceVariableOrWriteNode < Node
     @value: Prism::node
 
@@ -11009,8 +11477,10 @@ module Prism
 
   # Represents referencing an instance variable.
   #
-  #     @foo
-  #     ^^^^
+  # ```rb
+  # @foo
+  # ^^^^
+  # ```
   class InstanceVariableReadNode < Node
     @name: Symbol
 
@@ -11072,9 +11542,11 @@ module Prism
     #
     # The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
     #
-    #     @x     # name `:@x`
+    # ```rb
+    # @x     # name `:@x`
     #
-    #     @_test # name `:@_test`
+    # @_test # name `:@_test`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -11085,8 +11557,10 @@ module Prism
 
   # Represents writing to an instance variable in a context that doesn't have an explicit value.
   #
-  #     @foo, @bar = baz
-  #     ^^^^  ^^^^
+  # ```rb
+  # @foo, @bar = baz
+  # ^^^^  ^^^^
+  # ```
   class InstanceVariableTargetNode < Node
     @name: Symbol
 
@@ -11157,8 +11631,10 @@ module Prism
 
   # Represents writing to an instance variable.
   #
-  #     @foo = 1
-  #     ^^^^^^^^
+  # ```rb
+  # @foo = 1
+  # ^^^^^^^^
+  # ```
   class InstanceVariableWriteNode < Node
     @operator_loc: Location
 
@@ -11226,9 +11702,11 @@ module Prism
     #
     # The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
     #
-    #     @x = :y       # name `:@x`
+    # ```rb
+    # @x = :y       # name `:@x`
     #
-    #     @_foo = "bar" # name `@_foo`
+    # @_foo = "bar" # name `@_foo`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -11239,8 +11717,10 @@ module Prism
     #
     # The Location of the variable name.
     #
-    #     @_x = 1
-    #     ^^^
+    # ```rb
+    # @_x = 1
+    # ^^^
+    # ```
     #
     # : () -> Location
     def name_loc: () -> Location
@@ -11257,11 +11737,13 @@ module Prism
     #
     # The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     @foo = :bar
-    #            ^^^^
+    # ```rb
+    # @foo = :bar
+    #        ^^^^
     #
-    #     @_x = 1234
-    #           ^^^^
+    # @_x = 1234
+    #       ^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -11272,8 +11754,10 @@ module Prism
     #
     # The Location of the `=` operator.
     #
-    #     @x = y
-    #        ^
+    # ```rb
+    # @x = y
+    #    ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -11299,8 +11783,10 @@ module Prism
 
   # Represents an integer number literal.
   #
-  #     1
-  #     ^
+  # ```rb
+  # 1
+  # ^
+  # ```
   class IntegerNode < Node
     @value: Integer
 
@@ -11395,8 +11881,10 @@ module Prism
 
   # Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
   #
-  #     if /foo #{bar} baz/ then end
-  #        ^^^^^^^^^^^^^^^^
+  # ```rb
+  # if /foo #{bar} baz/ then end
+  #    ^^^^^^^^^^^^^^^^
+  # ```
   class InterpolatedMatchLastLineNode < Node
     @closing_loc: Location
 
@@ -11585,8 +12073,10 @@ module Prism
 
   # Represents a regular expression literal that contains interpolation.
   #
-  #     /foo #{bar} baz/
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # /foo #{bar} baz/
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class InterpolatedRegularExpressionNode < Node
     @closing_loc: Location
 
@@ -11775,8 +12265,10 @@ module Prism
 
   # Represents a string literal that contains interpolation.
   #
-  #     "foo #{bar} baz"
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # "foo #{bar} baz"
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class InterpolatedStringNode < Node
     @closing_loc: Location?
 
@@ -11911,8 +12403,10 @@ module Prism
 
   # Represents a symbol literal that contains interpolation.
   #
-  #     :"foo #{bar} baz"
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # :"foo #{bar} baz"
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class InterpolatedSymbolNode < Node
     @closing_loc: Location?
 
@@ -12035,8 +12529,10 @@ module Prism
 
   # Represents an xstring literal that contains interpolation.
   #
-  #     `foo #{bar} baz`
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # `foo #{bar} baz`
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class InterpolatedXStringNode < Node
     @closing_loc: Location
 
@@ -12159,8 +12655,10 @@ module Prism
 
   # Represents reading from the implicit `it` local variable.
   #
-  #     -> { it }
-  #          ^^
+  # ```rb
+  # -> { it }
+  #      ^^
+  # ```
   class ItLocalVariableReadNode < Node
     # Initialize a new ItLocalVariableReadNode node.
     #
@@ -12221,8 +12719,10 @@ module Prism
 
   # Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
   #
-  #     -> { it + it }
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # -> { it + it }
+  # ^^^^^^^^^^^^^^
+  # ```
   class ItParametersNode < Node
     # Initialize a new ItParametersNode node.
     #
@@ -12283,8 +12783,10 @@ module Prism
 
   # Represents a hash literal without opening and closing braces.
   #
-  #     foo(a: b)
-  #         ^^^^
+  # ```rb
+  # foo(a: b)
+  #     ^^^^
+  # ```
   class KeywordHashNode < Node
     @elements: Array[AssocNode | AssocSplatNode]
 
@@ -12361,9 +12863,11 @@ module Prism
 
   # Represents a keyword rest parameter to a method, block, or lambda definition.
   #
-  #     def a(**b)
-  #           ^^^
-  #     end
+  # ```rb
+  # def a(**b)
+  #       ^^^
+  # end
+  # ```
   class KeywordRestParameterNode < Node
     @operator_loc: Location
 
@@ -12484,8 +12988,10 @@ module Prism
 
   # Represents using a lambda literal (not the lambda method call).
   #
-  #     ->(value) { value * 2 }
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # ->(value) { value * 2 }
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class LambdaNode < Node
     @body: (StatementsNode | BeginNode)?
 
@@ -12654,8 +13160,10 @@ module Prism
 
   # Represents the use of the `&&=` operator for assignment to a local variable.
   #
-  #     target &&= value
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # target &&= value
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class LocalVariableAndWriteNode < Node
     @depth: Integer
 
@@ -12790,8 +13298,10 @@ module Prism
 
   # Represents assigning to a local variable using an operator that isn't `=`.
   #
-  #     target += value
-  #     ^^^^^^^^^^^^^^^
+  # ```rb
+  # target += value
+  # ^^^^^^^^^^^^^^^
+  # ```
   class LocalVariableOperatorWriteNode < Node
     @depth: Integer
 
@@ -12928,8 +13438,10 @@ module Prism
 
   # Represents the use of the `||=` operator for assignment to a local variable.
   #
-  #     target ||= value
-  #     ^^^^^^^^^^^^^^^^
+  # ```rb
+  # target ||= value
+  # ^^^^^^^^^^^^^^^^
+  # ```
   class LocalVariableOrWriteNode < Node
     @depth: Integer
 
@@ -13064,8 +13576,10 @@ module Prism
 
   # Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
   #
-  #     foo
-  #     ^^^
+  # ```rb
+  # foo
+  # ^^^
+  # ```
   class LocalVariableReadNode < Node
     @name: Symbol
 
@@ -13129,13 +13643,17 @@ module Prism
     #
     # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
     #
-    #     x      # name `:x`
+    # ```rb
+    # x      # name `:x`
     #
-    #     _Test  # name `:_Test`
+    # _Test  # name `:_Test`
     #
+    # ```
     # Note that this can also be an underscore followed by a number for the default block parameters.
     #
-    #     _1     # name `:_1`
+    # ```rb
+    # _1     # name `:_1`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -13145,10 +13663,12 @@ module Prism
     #
     # The number of visible scopes that should be searched to find the origin of this local variable.
     #
-    #     foo = 1; foo # depth 0
+    # ```rb
+    # foo = 1; foo # depth 0
     #
-    #     bar = 2; tap { bar } # depth 1
+    # bar = 2; tap { bar } # depth 1
     #
+    # ```
     # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
     #
     # : () -> Integer
@@ -13160,11 +13680,13 @@ module Prism
 
   # Represents writing to a local variable in a context that doesn't have an explicit value.
   #
-  #     foo, bar = baz
-  #     ^^^  ^^^
+  # ```rb
+  # foo, bar = baz
+  # ^^^  ^^^
   #
-  #     foo => baz
-  #            ^^^
+  # foo => baz
+  #        ^^^
+  # ```
   class LocalVariableTargetNode < Node
     @name: Symbol
 
@@ -13245,8 +13767,10 @@ module Prism
 
   # Represents writing to a local variable.
   #
-  #     foo = 1
-  #     ^^^^^^^
+  # ```rb
+  # foo = 1
+  # ^^^^^^^
+  # ```
   class LocalVariableWriteNode < Node
     @operator_loc: Location
 
@@ -13316,9 +13840,11 @@ module Prism
     #
     # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
     #
-    #     foo = :bar # name `:foo`
+    # ```rb
+    # foo = :bar # name `:foo`
     #
-    #     abc = 123  # name `:abc`
+    # abc = 123  # name `:abc`
+    # ```
     #
     # : () -> Symbol
     def name: () -> Symbol
@@ -13328,10 +13854,12 @@ module Prism
     #
     # The number of semantic scopes we have to traverse to find the declaration of this variable.
     #
-    #     foo = 1         # depth 0
+    # ```rb
+    # foo = 1         # depth 0
     #
-    #     tap { foo = 1 } # depth 1
+    # tap { foo = 1 } # depth 1
     #
+    # ```
     # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
     #
     # : () -> Integer
@@ -13343,8 +13871,10 @@ module Prism
     #
     # The Location of the variable name.
     #
-    #     foo = :bar
-    #     ^^^
+    # ```rb
+    # foo = :bar
+    # ^^^
+    # ```
     #
     # : () -> Location
     def name_loc: () -> Location
@@ -13361,15 +13891,19 @@ module Prism
     #
     # The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     foo = :bar
-    #           ^^^^
+    # ```rb
+    # foo = :bar
+    #       ^^^^
     #
-    #     abc = 1234
-    #           ^^^^
+    # abc = 1234
+    #       ^^^^
     #
+    # ```
     # Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
     #
-    #     foo = foo
+    # ```rb
+    # foo = foo
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -13380,8 +13914,10 @@ module Prism
     #
     # The Location of the `=` operator.
     #
-    #     x = :y
-    #       ^
+    # ```rb
+    # x = :y
+    #   ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -13407,8 +13943,10 @@ module Prism
 
   # Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
   #
-  #     if /foo/i then end
-  #        ^^^^^^
+  # ```rb
+  # if /foo/i then end
+  #    ^^^^^^
+  # ```
   class MatchLastLineNode < Node
     @unescaped: String
 
@@ -13623,8 +14161,10 @@ module Prism
 
   # Represents the use of the modifier `in` operator.
   #
-  #     foo in bar
-  #     ^^^^^^^^^^
+  # ```rb
+  # foo in bar
+  # ^^^^^^^^^^
+  # ```
   class MatchPredicateNode < Node
     @keyword_loc: Location
 
@@ -13731,8 +14271,10 @@ module Prism
 
   # Represents the use of the `=>` operator.
   #
-  #     foo => bar
-  #     ^^^^^^^^^^
+  # ```rb
+  # foo => bar
+  # ^^^^^^^^^^
+  # ```
   class MatchRequiredNode < Node
     @operator_loc: Location
 
@@ -13798,8 +14340,10 @@ module Prism
     #
     # Represents the left-hand side of the operator.
     #
-    #     foo => bar
-    #     ^^^
+    # ```rb
+    # foo => bar
+    # ^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -13811,45 +14355,59 @@ module Prism
     #
     # Anything that looks like a local variable name (including `_`) will result in a `LocalVariableTargetNode`.
     #
-    #     foo => a # This is equivalent to writing `a = foo`
-    #            ^
+    # ```rb
+    # foo => a # This is equivalent to writing `a = foo`
+    #        ^
     #
+    # ```
     # Using an explicit `Array` or combining expressions with `,` will result in a `ArrayPatternNode`. This can be preceded by a constant.
     #
-    #     foo => [a]
-    #            ^^^
+    # ```rb
+    # foo => [a]
+    #        ^^^
     #
-    #     foo => a, b
-    #            ^^^^
+    # foo => a, b
+    #        ^^^^
     #
-    #     foo => Bar[a, b]
-    #            ^^^^^^^^^
+    # foo => Bar[a, b]
+    #        ^^^^^^^^^
     #
+    # ```
     # If the array pattern contains at least two wildcard matches, a `FindPatternNode` is created instead.
     #
-    #     foo => *, 1, *a
-    #            ^^^^^
+    # ```rb
+    # foo => *, 1, *a
+    #        ^^^^^
     #
+    # ```
     # Using an explicit `Hash` or a constant with square brackets and hash keys in the square brackets will result in a `HashPatternNode`.
     #
-    #     foo => { a: 1, b: }
+    # ```rb
+    # foo => { a: 1, b: }
     #
-    #     foo => Bar[a: 1, b:]
+    # foo => Bar[a: 1, b:]
     #
-    #     foo => Bar[**]
+    # foo => Bar[**]
     #
+    # ```
     # To use any variable that needs run time evaluation, pinning is required. This results in a `PinnedVariableNode`
     #
-    #     foo => ^a
-    #            ^^
+    # ```rb
+    # foo => ^a
+    #        ^^
     #
+    # ```
     # Similar, any expression can be used with pinning. This results in a `PinnedExpressionNode`.
     #
-    #     foo => ^(a + 1)
+    # ```rb
+    # foo => ^(a + 1)
     #
+    # ```
     # Anything else will result in the regular node for that expression, for example a `ConstantReadNode`.
     #
-    #     foo => CONST
+    # ```rb
+    # foo => CONST
+    # ```
     #
     # : () -> Prism::node
     def pattern: () -> Prism::node
@@ -13860,8 +14418,10 @@ module Prism
     #
     # The Location of the operator.
     #
-    #     foo => bar
-    #         ^^
+    # ```rb
+    # foo => bar
+    #     ^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -13887,8 +14447,10 @@ module Prism
 
   # Represents writing local variables using a regular expression match with named capture groups.
   #
-  #     /(?<foo>bar)/ =~ baz
-  #     ^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # /(?<foo>bar)/ =~ baz
+  # ^^^^^^^^^^^^^^^^^^^^
+  # ```
   class MatchWriteNode < Node
     @call: CallNode
 
@@ -13969,8 +14531,10 @@ module Prism
 
   # Represents a module declaration involving the `module` keyword.
   #
-  #     module Foo end
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # module Foo end
+  # ^^^^^^^^^^^^^^
+  # ```
   class ModuleNode < Node
     @name: Symbol
 
@@ -14123,13 +14687,17 @@ module Prism
 
   # Represents a multi-target expression.
   #
-  #     a, (b, c) = 1, 2, 3
-  #        ^^^^^^
+  # ```rb
+  # a, (b, c) = 1, 2, 3
+  #    ^^^^^^
   #
+  # ```
   # This can be a part of `MultiWriteNode` as above, or the target of a `for` loop
   #
-  #     for a, b in [[1, 2], [3, 4]]
-  #         ^^^^
+  # ```rb
+  # for a, b in [[1, 2], [3, 4]]
+  #     ^^^^
+  # ```
   class MultiTargetNode < Node
     @rparen_loc: Location?
 
@@ -14199,13 +14767,17 @@ module Prism
     #
     # Represents the targets expressions before a splat node.
     #
-    #     a, (b, c, *) = 1, 2, 3, 4, 5
-    #         ^^^^
+    # ```rb
+    # a, (b, c, *) = 1, 2, 3, 4, 5
+    #     ^^^^
     #
+    # ```
     # The splat node can be absent, in that case all target expressions are in the left field.
     #
-    #     a, (b, c) = 1, 2, 3, 4, 5
-    #         ^^^^
+    # ```rb
+    # a, (b, c) = 1, 2, 3, 4, 5
+    #     ^^^^
+    # ```
     #
     # : () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode]
     def lefts: () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode]
@@ -14215,18 +14787,24 @@ module Prism
     #
     # Represents a splat node in the target expression.
     #
-    #     a, (b, *c) = 1, 2, 3, 4
-    #            ^^
+    # ```rb
+    # a, (b, *c) = 1, 2, 3, 4
+    #        ^^
     #
+    # ```
     # The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
     #
-    #     a, (b, *) = 1, 2, 3, 4
-    #            ^
+    # ```rb
+    # a, (b, *) = 1, 2, 3, 4
+    #        ^
     #
+    # ```
     # If the `*` is omitted, this field will contain an `ImplicitRestNode`
     #
-    #     a, (b,) = 1, 2, 3, 4
-    #          ^
+    # ```rb
+    # a, (b,) = 1, 2, 3, 4
+    #      ^
+    # ```
     #
     # : () -> (ImplicitRestNode | SplatNode)?
     def rest: () -> (ImplicitRestNode | SplatNode)?
@@ -14236,8 +14814,10 @@ module Prism
     #
     # Represents the targets expressions after a splat node.
     #
-    #     a, (*, b, c) = 1, 2, 3, 4, 5
-    #            ^^^^
+    # ```rb
+    # a, (*, b, c) = 1, 2, 3, 4, 5
+    #        ^^^^
+    # ```
     #
     # : () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode]
     def rights: () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode]
@@ -14248,8 +14828,10 @@ module Prism
     #
     # The Location of the opening parenthesis.
     #
-    #     a, (b, c) = 1, 2, 3
-    #        ^
+    # ```rb
+    # a, (b, c) = 1, 2, 3
+    #    ^
+    # ```
     #
     # : () -> Location?
     def lparen_loc: () -> Location?
@@ -14267,8 +14849,10 @@ module Prism
     #
     # The Location of the closing parenthesis.
     #
-    #     a, (b, c) = 1, 2, 3
-    #             ^
+    # ```rb
+    # a, (b, c) = 1, 2, 3
+    #         ^
+    # ```
     #
     # : () -> Location?
     def rparen_loc: () -> Location?
@@ -14302,8 +14886,10 @@ module Prism
 
   # Represents a write to a multi-target expression.
   #
-  #     a, b, c = 1, 2, 3
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # a, b, c = 1, 2, 3
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class MultiWriteNode < Node
     @value: Prism::node
 
@@ -14377,13 +14963,17 @@ module Prism
     #
     # Represents the targets expressions before a splat node.
     #
-    #     a, b, * = 1, 2, 3, 4, 5
-    #     ^^^^
+    # ```rb
+    # a, b, * = 1, 2, 3, 4, 5
+    # ^^^^
     #
+    # ```
     # The splat node can be absent, in that case all target expressions are in the left field.
     #
-    #     a, b, c = 1, 2, 3, 4, 5
-    #     ^^^^^^^
+    # ```rb
+    # a, b, c = 1, 2, 3, 4, 5
+    # ^^^^^^^
+    # ```
     #
     # : () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
     def lefts: () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
@@ -14393,18 +14983,24 @@ module Prism
     #
     # Represents a splat node in the target expression.
     #
-    #     a, b, *c = 1, 2, 3, 4
-    #           ^^
+    # ```rb
+    # a, b, *c = 1, 2, 3, 4
+    #       ^^
     #
+    # ```
     # The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
     #
-    #     a, b, * = 1, 2, 3, 4
-    #           ^
+    # ```rb
+    # a, b, * = 1, 2, 3, 4
+    #       ^
     #
+    # ```
     # If the `*` is omitted, this field will contain an `ImplicitRestNode`
     #
-    #     a, b, = 1, 2, 3, 4
-    #         ^
+    # ```rb
+    # a, b, = 1, 2, 3, 4
+    #     ^
+    # ```
     #
     # : () -> (ImplicitRestNode | SplatNode)?
     def rest: () -> (ImplicitRestNode | SplatNode)?
@@ -14414,8 +15010,10 @@ module Prism
     #
     # Represents the targets expressions after a splat node.
     #
-    #     a, *, b, c = 1, 2, 3, 4, 5
-    #           ^^^^
+    # ```rb
+    # a, *, b, c = 1, 2, 3, 4, 5
+    #       ^^^^
+    # ```
     #
     # : () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
     def rights: () -> Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
@@ -14426,8 +15024,10 @@ module Prism
     #
     # The Location of the opening parenthesis.
     #
-    #     (a, b, c) = 1, 2, 3
-    #     ^
+    # ```rb
+    # (a, b, c) = 1, 2, 3
+    # ^
+    # ```
     #
     # : () -> Location?
     def lparen_loc: () -> Location?
@@ -14445,8 +15045,10 @@ module Prism
     #
     # The Location of the closing parenthesis.
     #
-    #     (a, b, c) = 1, 2, 3
-    #             ^
+    # ```rb
+    # (a, b, c) = 1, 2, 3
+    #         ^
+    # ```
     #
     # : () -> Location?
     def rparen_loc: () -> Location?
@@ -14464,8 +15066,10 @@ module Prism
     #
     # The Location of the operator.
     #
-    #     a, b, c = 1, 2, 3
-    #             ^
+    # ```rb
+    # a, b, c = 1, 2, 3
+    #         ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -14482,8 +15086,10 @@ module Prism
     #
     # The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     a, b, c = 1, 2, 3
-    #               ^^^^^^^
+    # ```rb
+    # a, b, c = 1, 2, 3
+    #           ^^^^^^^
+    # ```
     #
     # : () -> Prism::node
     def value: () -> Prism::node
@@ -14518,8 +15124,10 @@ module Prism
 
   # Represents the use of the `next` keyword.
   #
-  #     next 1
-  #     ^^^^^^
+  # ```rb
+  # next 1
+  # ^^^^^^
+  # ```
   class NextNode < Node
     @keyword_loc: Location
 
@@ -14616,8 +15224,10 @@ module Prism
 
   # Represents the use of the `nil` keyword.
   #
-  #     nil
-  #     ^^^
+  # ```rb
+  # nil
+  # ^^^
+  # ```
   class NilNode < Node
     # Initialize a new NilNode node.
     #
@@ -14678,9 +15288,11 @@ module Prism
 
   # Represents the use of `&nil` inside method arguments.
   #
-  #     def a(&nil)
-  #           ^^^^
-  #     end
+  # ```rb
+  # def a(&nil)
+  #       ^^^^
+  # end
+  # ```
   class NoBlockParameterNode < Node
     @keyword_loc: Location
 
@@ -14793,9 +15405,11 @@ module Prism
 
   # Represents the use of `**nil` inside method arguments.
   #
-  #     def a(**nil)
-  #           ^^^^^
-  #     end
+  # ```rb
+  # def a(**nil)
+  #       ^^^^^
+  # end
+  # ```
   class NoKeywordsParameterNode < Node
     @keyword_loc: Location
 
@@ -14908,8 +15522,10 @@ module Prism
 
   # Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
   #
-  #     -> { _1 + _2 }
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  # ```
   class NumberedParametersNode < Node
     @maximum: Integer
 
@@ -14980,8 +15596,10 @@ module Prism
 
   # Represents reading a numbered reference to a capture in the previous match.
   #
-  #     $1
-  #     ^^
+  # ```rb
+  # $1
+  # ^^
+  # ```
   class NumberedReferenceReadNode < Node
     @number: Integer
 
@@ -15043,11 +15661,13 @@ module Prism
     #
     # The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
     #
-    #     $1          # number `1`
+    # ```rb
+    # $1          # number `1`
     #
-    #     $5432       # number `5432`
+    # $5432       # number `5432`
     #
-    #     $4294967296 # number `0`
+    # $4294967296 # number `0`
+    # ```
     #
     # : () -> Integer
     def number: () -> Integer
@@ -15058,9 +15678,11 @@ module Prism
 
   # Represents an optional keyword parameter to a method, block, or lambda definition.
   #
-  #     def a(b: 1)
-  #           ^^^^
-  #     end
+  # ```rb
+  # def a(b: 1)
+  #       ^^^^
+  # end
+  # ```
   class OptionalKeywordParameterNode < Node
     @value: Prism::node
 
@@ -15165,9 +15787,11 @@ module Prism
 
   # Represents an optional parameter to a method, block, or lambda definition.
   #
-  #     def a(b = 1)
-  #           ^^^^^
-  #     end
+  # ```rb
+  # def a(b = 1)
+  #       ^^^^^
+  # end
+  # ```
   class OptionalParameterNode < Node
     @value: Prism::node
 
@@ -15298,8 +15922,10 @@ module Prism
 
   # Represents the use of the `||` operator or the `or` keyword.
   #
-  #     left or right
-  #     ^^^^^^^^^^^^^
+  # ```rb
+  # left or right
+  # ^^^^^^^^^^^^^
+  # ```
   class OrNode < Node
     @operator_loc: Location
 
@@ -15365,11 +15991,13 @@ module Prism
     #
     # Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     left or right
-    #     ^^^^
+    # ```rb
+    # left or right
+    # ^^^^
     #
-    #     1 || 2
-    #     ^
+    # 1 || 2
+    # ^
+    # ```
     #
     # : () -> Prism::node
     def left: () -> Prism::node
@@ -15379,11 +16007,13 @@ module Prism
     #
     # Represents the right side of the expression.
     #
-    #     left || right
-    #             ^^^^^
+    # ```rb
+    # left || right
+    #         ^^^^^
     #
-    #     1 or 2
-    #          ^
+    # 1 or 2
+    #      ^
+    # ```
     #
     # : () -> Prism::node
     def right: () -> Prism::node
@@ -15394,8 +16024,10 @@ module Prism
     #
     # The Location of the `or` keyword or the `||` operator.
     #
-    #     left or right
-    #          ^^
+    # ```rb
+    # left or right
+    #      ^^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -15421,9 +16053,11 @@ module Prism
 
   # Represents the list of parameters on a method, block, or lambda definition.
   #
-  #     def a(b, c, d)
-  #           ^^^^^^^
-  #     end
+  # ```rb
+  # def a(b, c, d)
+  #       ^^^^^^^
+  # end
+  # ```
   class ParametersNode < Node
     @block: (BlockParameterNode | NoBlockParameterNode)?
 
@@ -15554,8 +16188,10 @@ module Prism
 
   # Represents a parenthesized expression
   #
-  #     (10 + 34)
-  #     ^^^^^^^^^
+  # ```rb
+  # (10 + 34)
+  # ^^^^^^^^^
+  # ```
   class ParenthesesNode < Node
     @closing_loc: Location
 
@@ -15684,8 +16320,10 @@ module Prism
 
   # Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
   #
-  #     foo in ^(bar)
-  #            ^^^^^^
+  # ```rb
+  # foo in ^(bar)
+  #        ^^^^^^
+  # ```
   class PinnedExpressionNode < Node
     @rparen_loc: Location
 
@@ -15753,8 +16391,10 @@ module Prism
     #
     # The expression used in the pinned expression
     #
-    #     foo in ^(bar)
-    #              ^^^
+    # ```rb
+    # foo in ^(bar)
+    #          ^^^
+    # ```
     #
     # : () -> Prism::node
     def expression: () -> Prism::node
@@ -15765,8 +16405,10 @@ module Prism
     #
     # The Location of the `^` operator
     #
-    #     foo in ^(bar)
-    #            ^
+    # ```rb
+    # foo in ^(bar)
+    #        ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -15784,8 +16426,10 @@ module Prism
     #
     # The Location of the opening parenthesis.
     #
-    #     foo in ^(bar)
-    #             ^
+    # ```rb
+    # foo in ^(bar)
+    #         ^
+    # ```
     #
     # : () -> Location
     def lparen_loc: () -> Location
@@ -15803,8 +16447,10 @@ module Prism
     #
     # The Location of the closing parenthesis.
     #
-    #     foo in ^(bar)
-    #                 ^
+    # ```rb
+    # foo in ^(bar)
+    #             ^
+    # ```
     #
     # : () -> Location
     def rparen_loc: () -> Location
@@ -15846,8 +16492,10 @@ module Prism
 
   # Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
   #
-  #     foo in ^bar
-  #            ^^^^
+  # ```rb
+  # foo in ^bar
+  #        ^^^^
+  # ```
   class PinnedVariableNode < Node
     @operator_loc: Location
 
@@ -15911,8 +16559,10 @@ module Prism
     #
     # The variable used in the pinned expression
     #
-    #     foo in ^bar
-    #             ^^^
+    # ```rb
+    # foo in ^bar
+    #         ^^^
+    # ```
     #
     # : () -> (LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode)
     def variable: () -> (LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode)
@@ -15923,8 +16573,10 @@ module Prism
     #
     # The Location of the `^` operator
     #
-    #     foo in ^bar
-    #            ^
+    # ```rb
+    # foo in ^bar
+    #        ^
+    # ```
     #
     # : () -> Location
     def operator_loc: () -> Location
@@ -15950,8 +16602,10 @@ module Prism
 
   # Represents the use of the `END` keyword.
   #
-  #     END { foo }
-  #     ^^^^^^^^^^^
+  # ```rb
+  # END { foo }
+  # ^^^^^^^^^^^
+  # ```
   class PostExecutionNode < Node
     @closing_loc: Location
 
@@ -16100,8 +16754,10 @@ module Prism
 
   # Represents the use of the `BEGIN` keyword.
   #
-  #     BEGIN { foo }
-  #     ^^^^^^^^^^^^^
+  # ```rb
+  # BEGIN { foo }
+  # ^^^^^^^^^^^^^
+  # ```
   class PreExecutionNode < Node
     @closing_loc: Location
 
@@ -16329,11 +16985,13 @@ module Prism
 
   # Represents the use of the `..` or `...` operators.
   #
-  #     1..2
-  #     ^^^^
+  # ```rb
+  # 1..2
+  # ^^^^
   #
-  #     c if a =~ /left/ ... b =~ /right/
-  #          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  # c if a =~ /left/ ... b =~ /right/
+  #      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class RangeNode < Node
     @operator_loc: Location
 
@@ -16405,11 +17063,13 @@ module Prism
     #
     # The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     1...
-    #     ^
+    # ```rb
+    # 1...
+    # ^
     #
-    #     hello...goodbye
-    #     ^^^^^
+    # hello...goodbye
+    # ^^^^^
+    # ```
     #
     # : () -> Prism::node?
     def left: () -> Prism::node?
@@ -16419,11 +17079,13 @@ module Prism
     #
     # The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     ..5
-    #       ^
+    # ```rb
+    # ..5
+    #   ^
     #
-    #     1...foo
-    #         ^^^
+    # 1...foo
+    #     ^^^
+    # ```
     # If neither right-hand or left-hand side was included, this will be an ErrorRecoveryNode.
     #
     # : () -> Prism::node?
@@ -16459,8 +17121,10 @@ module Prism
 
   # Represents a rational number literal.
   #
-  #     1.0r
-  #     ^^^^
+  # ```rb
+  # 1.0r
+  # ^^^^
+  # ```
   class RationalNode < Node
     @denominator: Integer
 
@@ -16548,7 +17212,9 @@ module Prism
     #
     # The numerator of the rational number.
     #
-    #     1.5r # numerator 3
+    # ```rb
+    # 1.5r # numerator 3
+    # ```
     #
     # : () -> Integer
     def numerator: () -> Integer
@@ -16558,7 +17224,9 @@ module Prism
     #
     # The denominator of the rational number.
     #
-    #     1.5r # denominator 2
+    # ```rb
+    # 1.5r # denominator 2
+    # ```
     #
     # : () -> Integer
     def denominator: () -> Integer
@@ -16569,8 +17237,10 @@ module Prism
 
   # Represents the use of the `redo` keyword.
   #
-  #     redo
-  #     ^^^^
+  # ```rb
+  # redo
+  # ^^^^
+  # ```
   class RedoNode < Node
     # Initialize a new RedoNode node.
     #
@@ -16631,8 +17301,10 @@ module Prism
 
   # Represents a regular expression literal with no interpolation.
   #
-  #     /foo/i
-  #     ^^^^^^
+  # ```rb
+  # /foo/i
+  # ^^^^^^
+  # ```
   class RegularExpressionNode < Node
     @unescaped: String
 
@@ -16847,9 +17519,11 @@ module Prism
 
   # Represents a required keyword parameter to a method, block, or lambda definition.
   #
-  #     def a(b: )
-  #           ^^
-  #     end
+  # ```rb
+  # def a(b: )
+  #       ^^
+  # end
+  # ```
   class RequiredKeywordParameterNode < Node
     @name_loc: Location
 
@@ -16944,9 +17618,11 @@ module Prism
 
   # Represents a required parameter to a method, block, or lambda definition.
   #
-  #     def a(b)
-  #           ^
-  #     end
+  # ```rb
+  # def a(b)
+  #       ^
+  # end
+  # ```
   class RequiredParameterNode < Node
     @name: Symbol
 
@@ -17023,8 +17699,10 @@ module Prism
 
   # Represents an expression modified with a rescue.
   #
-  #     foo rescue nil
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # foo rescue nil
+  # ^^^^^^^^^^^^^^
+  # ```
   class RescueModifierNode < Node
     @rescue_expression: Prism::node
 
@@ -17131,12 +17809,14 @@ module Prism
 
   # Represents a rescue statement.
   #
-  #     begin
-  #     rescue Foo, *splat, Bar => ex
-  #       foo
-  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  #     end
+  # ```rb
+  # begin
+  # rescue Foo, *splat, Bar => ex
+  #   foo
+  # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  # end
   #
+  # ```
   # `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field.
   class RescueNode < Node
     @subsequent: RescueNode?
@@ -17316,9 +17996,11 @@ module Prism
 
   # Represents a rest parameter to a method, block, or lambda definition.
   #
-  #     def a(*b)
-  #           ^^
-  #     end
+  # ```rb
+  # def a(*b)
+  #       ^^
+  # end
+  # ```
   class RestParameterNode < Node
     @operator_loc: Location
 
@@ -17439,8 +18121,10 @@ module Prism
 
   # Represents the use of the `retry` keyword.
   #
-  #     retry
-  #     ^^^^^
+  # ```rb
+  # retry
+  # ^^^^^
+  # ```
   class RetryNode < Node
     # Initialize a new RetryNode node.
     #
@@ -17501,8 +18185,10 @@ module Prism
 
   # Represents the use of the `return` keyword.
   #
-  #     return 1
-  #     ^^^^^^^^
+  # ```rb
+  # return 1
+  # ^^^^^^^^
+  # ```
   class ReturnNode < Node
     @arguments: ArgumentsNode?
 
@@ -17599,8 +18285,10 @@ module Prism
 
   # Represents the `self` keyword.
   #
-  #     self
-  #     ^^^^
+  # ```rb
+  # self
+  # ^^^^
+  # ```
   class SelfNode < Node
     # Initialize a new SelfNode node.
     #
@@ -17661,9 +18349,11 @@ module Prism
 
   # This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
   #
-  #     # shareable_constant_value: literal
-  #     C = { a: 1 }
-  #     ^^^^^^^^^^^^
+  # ```rb
+  # # shareable_constant_value: literal
+  # C = { a: 1 }
+  # ^^^^^^^^^^^^
+  # ```
   class ShareableConstantNode < Node
     @write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode
 
@@ -17752,8 +18442,10 @@ module Prism
 
   # Represents a singleton class declaration involving the `class` keyword.
   #
-  #     class << self end
-  #     ^^^^^^^^^^^^^^^^^
+  # ```rb
+  # class << self end
+  # ^^^^^^^^^^^^^^^^^
+  # ```
   class SingletonClassNode < Node
     @end_keyword_loc: Location
 
@@ -17922,8 +18614,10 @@ module Prism
 
   # Represents the use of the `__ENCODING__` keyword.
   #
-  #     __ENCODING__
-  #     ^^^^^^^^^^^^
+  # ```rb
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  # ```
   class SourceEncodingNode < Node
     # Initialize a new SourceEncodingNode node.
     #
@@ -17984,8 +18678,10 @@ module Prism
 
   # Represents the use of the `__FILE__` keyword.
   #
-  #     __FILE__
-  #     ^^^^^^^^
+  # ```rb
+  # __FILE__
+  # ^^^^^^^^
+  # ```
   class SourceFileNode < Node
     @filepath: String
 
@@ -18080,8 +18776,10 @@ module Prism
 
   # Represents the use of the `__LINE__` keyword.
   #
-  #     __LINE__
-  #     ^^^^^^^^
+  # ```rb
+  # __LINE__
+  # ^^^^^^^^
+  # ```
   class SourceLineNode < Node
     # Initialize a new SourceLineNode node.
     #
@@ -18142,8 +18840,10 @@ module Prism
 
   # Represents the use of the splat operator.
   #
-  #     [*a]
-  #      ^^
+  # ```rb
+  # [*a]
+  #  ^^
+  # ```
   class SplatNode < Node
     @expression: Prism::node?
 
@@ -18240,8 +18940,10 @@ module Prism
 
   # Represents a set of statements contained within some scope.
   #
-  #     foo; bar; baz
-  #     ^^^^^^^^^^^^^
+  # ```rb
+  # foo; bar; baz
+  # ^^^^^^^^^^^^^
+  # ```
   class StatementsNode < Node
     @body: Array[Prism::node]
 
@@ -18312,14 +19014,16 @@ module Prism
 
   # Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
   #
-  #     "foo"
-  #     ^^^^^
+  # ```rb
+  # "foo"
+  # ^^^^^
   #
-  #     %w[foo]
-  #        ^^^
+  # %w[foo]
+  #    ^^^
   #
-  #     "foo #{bar} baz"
-  #      ^^^^      ^^^^
+  # "foo #{bar} baz"
+  #  ^^^^      ^^^^
+  # ```
   class StringNode < Node
     @unescaped: String
 
@@ -18492,12 +19196,14 @@ module Prism
 
   # Represents the use of the `super` keyword with parentheses or arguments.
   #
-  #     super()
-  #     ^^^^^^^
+  # ```rb
+  # super()
+  # ^^^^^^^
   #
-  #     super foo, bar
-  #     ^^^^^^^^^^^^^^
+  # super foo, bar
+  # ^^^^^^^^^^^^^^
   #
+  # ```
   # If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead.
   class SuperNode < Node
     @block: (BlockNode | BlockArgumentNode)?
@@ -18657,11 +19363,13 @@ module Prism
 
   # Represents a symbol literal or a symbol contained within a `%i` list.
   #
-  #     :foo
-  #     ^^^^
+  # ```rb
+  # :foo
+  # ^^^^
   #
-  #     %i[foo]
-  #        ^^^
+  # %i[foo]
+  #    ^^^
+  # ```
   class SymbolNode < Node
     @unescaped: String
 
@@ -18828,8 +19536,10 @@ module Prism
 
   # Represents the use of the literal `true` keyword.
   #
-  #     true
-  #     ^^^^
+  # ```rb
+  # true
+  # ^^^^
+  # ```
   class TrueNode < Node
     # Initialize a new TrueNode node.
     #
@@ -18890,8 +19600,10 @@ module Prism
 
   # Represents the use of the `undef` keyword.
   #
-  #     undef :foo, :bar, :baz
-  #     ^^^^^^^^^^^^^^^^^^^^^^
+  # ```rb
+  # undef :foo, :bar, :baz
+  # ^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class UndefNode < Node
     @keyword_loc: Location
 
@@ -18988,11 +19700,13 @@ module Prism
 
   # Represents the use of the `unless` keyword, either in the block form or the modifier form.
   #
-  #     bar unless foo
-  #     ^^^^^^^^^^^^^^
+  # ```rb
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
   #
-  #     unless foo then bar end
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  # unless foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  # ```
   class UnlessNode < Node
     @end_keyword_loc: Location?
 
@@ -19065,11 +19779,13 @@ module Prism
     #
     # The Location of the `unless` keyword.
     #
-    #     unless cond then bar end
-    #     ^^^^^^
+    # ```rb
+    # unless cond then bar end
+    # ^^^^^^
     #
-    #     bar unless cond
-    #         ^^^^^^
+    # bar unless cond
+    #     ^^^^^^
+    # ```
     #
     # : () -> Location
     def unless_keyword_loc: () -> Location
@@ -19086,11 +19802,13 @@ module Prism
     #
     # The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
-    #     unless cond then bar end
-    #            ^^^^
+    # ```rb
+    # unless cond then bar end
+    #        ^^^^
     #
-    #     bar unless cond
-    #                ^^^^
+    # bar unless cond
+    #            ^^^^
+    # ```
     #
     # : () -> Prism::node
     def predicate: () -> Prism::node
@@ -19101,8 +19819,10 @@ module Prism
     #
     # The Location of the `then` keyword, if present.
     #
-    #     unless cond then bar end
-    #                 ^^^^
+    # ```rb
+    # unless cond then bar end
+    #             ^^^^
+    # ```
     #
     # : () -> Location?
     def then_keyword_loc: () -> Location?
@@ -19120,8 +19840,10 @@ module Prism
     # The body of statements that will executed if the unless condition is
     # falsey. Will be `nil` if no body is provided.
     #
-    #     unless cond then bar end
-    #                      ^^^
+    # ```rb
+    # unless cond then bar end
+    #                  ^^^
+    # ```
     #
     # : () -> StatementsNode?
     def statements: () -> StatementsNode?
@@ -19131,8 +19853,10 @@ module Prism
     #
     # The else clause of the unless expression, if present.
     #
-    #     unless cond then bar else baz end
-    #                          ^^^^^^^^^^^^
+    # ```rb
+    # unless cond then bar else baz end
+    #                      ^^^^^^^^^^^^
+    # ```
     #
     # : () -> ElseNode?
     def else_clause: () -> ElseNode?
@@ -19143,8 +19867,10 @@ module Prism
     #
     # The Location of the `end` keyword, if present.
     #
-    #     unless cond then bar end
-    #                          ^^^
+    # ```rb
+    # unless cond then bar end
+    #                      ^^^
+    # ```
     #
     # : () -> Location?
     def end_keyword_loc: () -> Location?
@@ -19186,11 +19912,13 @@ module Prism
 
   # Represents the use of the `until` keyword, either in the block form or the modifier form.
   #
-  #     bar until foo
-  #     ^^^^^^^^^^^^^
+  # ```rb
+  # bar until foo
+  # ^^^^^^^^^^^^^
   #
-  #     until foo do bar end
-  #     ^^^^^^^^^^^^^^^^^^^^
+  # until foo do bar end
+  # ^^^^^^^^^^^^^^^^^^^^
+  # ```
   class UntilNode < Node
     @statements: StatementsNode?
 
@@ -19355,10 +20083,12 @@ module Prism
 
   # Represents the use of the `when` keyword within a case statement.
   #
-  #     case true
-  #     when true
-  #     ^^^^^^^^^
-  #     end
+  # ```rb
+  # case true
+  # when true
+  # ^^^^^^^^^
+  # end
+  # ```
   class WhenNode < Node
     @statements: StatementsNode?
 
@@ -19491,11 +20221,13 @@ module Prism
 
   # Represents the use of the `while` keyword, either in the block form or the modifier form.
   #
-  #     bar while foo
-  #     ^^^^^^^^^^^^^
+  # ```rb
+  # bar while foo
+  # ^^^^^^^^^^^^^
   #
-  #     while foo do bar end
-  #     ^^^^^^^^^^^^^^^^^^^^
+  # while foo do bar end
+  # ^^^^^^^^^^^^^^^^^^^^
+  # ```
   class WhileNode < Node
     @statements: StatementsNode?
 
@@ -19660,8 +20392,10 @@ module Prism
 
   # Represents an xstring literal with no interpolation.
   #
-  #     `foo`
-  #     ^^^^^
+  # ```rb
+  # `foo`
+  # ^^^^^
+  # ```
   class XStringNode < Node
     @unescaped: String
 
@@ -19822,8 +20556,10 @@ module Prism
 
   # Represents the use of the `yield` keyword.
   #
-  #     yield 1
-  #     ^^^^^^^
+  # ```rb
+  # yield 1
+  # ^^^^^^^
+  # ```
   class YieldNode < Node
     @rparen_loc: Location?