Rename SymbolNode#value_loc to SymbolNode#content_loc

config.yml

@@ -4552,7 +4552,7 @@ nodes:
     fields:
       - name: opening_loc
         type: location?
-      - name: value_loc
+      - name: content_loc
         type: location
       - name: closing_loc
         type: location?

lib/prism/node_ext.rb

@@ -488,5 +488,17 @@ def closing_loc # :nodoc
       end_keyword_loc
     end
   end
+
+  class SymbolNode < Node
+    #: () -> String
+    def value # :nodoc
+      content
+    end
+
+    #: () -> Location
+    def value_loc # :nodoc
+      content_loc
+    end
+  end
   # :startdoc:
 end

lib/prism/translation/parser/compiler.rb

@@ -140,7 +140,7 @@ def visit_assoc_node(node)
                 if key.opening.nil?
                   builder.match_hash_var([key.unescaped, srange(key.location)])
                 else
-                  builder.match_hash_var_from_str(token(key.opening_loc), [builder.string_internal([key.unescaped, srange(key.value_loc)])], token(key.closing_loc))
+                  builder.match_hash_var_from_str(token(key.opening_loc), [builder.string_internal([key.unescaped, srange(key.content_loc)])], token(key.closing_loc))
                 end
               else
                 builder.match_hash_var_from_str(token(key.opening_loc), visit_all(key.parts), token(key.closing_loc))
@@ -151,9 +151,9 @@ def visit_assoc_node(node)
               implicit_value = if value.is_a?(CallNode)
                 builder.call_method(nil, nil, [value.name, srange(value.message_loc)])
               elsif value.is_a?(ConstantReadNode)
-                builder.const([value.name, srange(key.value_loc)])
+                builder.const([value.name, srange(key.content_loc)])
               else
-                builder.ident([value.name, srange(key.value_loc)]).updated(:lvar)
+                builder.ident([value.name, srange(key.content_loc)]).updated(:lvar)
               end
 
               builder.pair_keyword([key.unescaped, srange(key)], implicit_value)
@@ -165,13 +165,13 @@ def visit_assoc_node(node)
           else
             parts =
               if key.is_a?(SymbolNode)
-                value = key.value
-                if value == ""
+                content = key.content
+                if content == ""
                   []
-                elsif value.include?("\n")
-                  string_nodes_from_line_continuations(key.unescaped, value, key.value_loc.start_offset, key.opening)
+                elsif content.include?("\n")
+                  string_nodes_from_line_continuations(key.unescaped, content, key.content_loc.start_offset, key.opening)
                 else
-                  [builder.string_internal([key.unescaped, srange(key.value_loc)])]
+                  [builder.string_internal([key.unescaped, srange(key.content_loc)])]
                 end
               else
                 visit_all(key.parts)
@@ -1775,12 +1775,12 @@ def visit_symbol_node(node)
             end
           else
             parts =
-              if node.value == ""
+              if node.content == ""
                 []
-              elsif node.value.include?("\n")
-                string_nodes_from_line_continuations(node.unescaped, node.value, node.value_loc.start_offset, node.opening)
+              elsif node.content.include?("\n")
+                string_nodes_from_line_continuations(node.unescaped, node.content, node.content_loc.start_offset, node.opening)
               else
-                [builder.string_internal([node.unescaped, srange(node.value_loc)])]
+                [builder.string_internal([node.unescaped, srange(node.content_loc)])]
               end
 
             builder.symbol_compose(

lib/prism/translation/ripper.rb

@@ -789,7 +789,7 @@ def visit_array_node(node)
             visit_words_sep(opening_loc, previous, element)
 
             bounds(element.location)
-            elements = on_qsymbols_add(elements, on_tstring_content(element.value))
+            elements = on_qsymbols_add(elements, on_tstring_content(element.content))
 
             previous = element
           end
@@ -853,7 +853,7 @@ def visit_array_node(node)
               on_symbols_add(
                 elements,
                 if element.is_a?(SymbolNode)
-                  on_word_add(on_word_new, on_tstring_content(element.value))
+                  on_word_add(on_word_new, on_tstring_content(element.content))
                 else
                   element.parts.inject(on_word_new) do |word, part|
                     word_part =
@@ -2351,8 +2351,8 @@ def visit_hash_pattern_node(node)
                 if (key = element.key).opening_loc.nil?
                   visit(key)
                 else
-                  bounds(key.value_loc)
-                  if (value = key.value).empty?
+                  bounds(key.content_loc)
+                  if (value = key.content).empty?
                     on_string_content
                   else
                     on_string_add(on_string_content, on_tstring_content(value))
@@ -3841,24 +3841,24 @@ def visit_super_node(node)
       def visit_symbol_node(node)
         with_string_bounds(node) do
           if (opening = node.opening)&.match?(/^%s|['"]:?$/)
-            bounds(node.value_loc)
+            bounds(node.content_loc)
             content = on_string_content
 
-            if !(value = node.value).empty?
+            if !(value = node.content).empty?
               content = on_string_add(content, on_tstring_content(value))
             end
 
             bounds(node.location)
             on_dyna_symbol(content)
           elsif (closing = node.closing) == ":"
             bounds(node.location)
-            on_label("#{node.value}:")
+            on_label("#{node.content}:")
           elsif opening.nil? && node.closing_loc.nil?
-            bounds(node.value_loc)
-            on_symbol_literal(visit_token(node.value))
+            bounds(node.content_loc)
+            on_symbol_literal(visit_token(node.content))
           else
-            bounds(node.value_loc)
-            on_symbol_literal(on_symbol(visit_token(node.value)))
+            bounds(node.content_loc)
+            on_symbol_literal(on_symbol(visit_token(node.content)))
           end
         end
       end

lib/prism/translation/ruby_parser.rb

@@ -1476,7 +1476,7 @@ def visit_super_node(node)
         # :foo
         # ^^^^
         def visit_symbol_node(node)
-          node.value == "!@" ? s(node, :lit, :"!@") : s(node, :lit, node.unescaped.to_sym)
+          node.content == "!@" ? s(node, :lit, :"!@") : s(node, :lit, node.unescaped.to_sym)
         end
 
         # true

snapshots/3.3-3.3/keyword_args_in_array_assignment.txt

@@ -39,14 +39,14 @@
             │       │           │   @ SymbolNode (location: (1,10)-(1,15))
             │       │           │   ├── flags: static_literal, forced_us_ascii_encoding
             │       │           │   ├── opening_loc: ∅
-            │       │           │   ├── value_loc: (1,10)-(1,14) = "axis"
+            │       │           │   ├── content_loc: (1,10)-(1,14) = "axis"
             │       │           │   ├── closing_loc: (1,14)-(1,15) = ":"
             │       │           │   └── unescaped: "axis"
             │       │           ├── value:
             │       │           │   @ SymbolNode (location: (1,16)-(1,18))
             │       │           │   ├── flags: static_literal, forced_us_ascii_encoding
             │       │           │   ├── opening_loc: (1,16)-(1,17) = ":"
-            │       │           │   ├── value_loc: (1,17)-(1,18) = "y"
+            │       │           │   ├── content_loc: (1,17)-(1,18) = "y"
             │       │           │   ├── closing_loc: ∅
             │       │           │   └── unescaped: "y"
             │       │           └── operator_loc: ∅