Add support for symbol and string literals in TypesExplainer

- Add LITERALMATCH regex constant to match symbol (:symbol) and string ('string', "string") literals
- Update TypesExplainer parser to recognize symbol and string literal types
- Format literal values as "a literal value :symbol" for better readability
- Add comprehensive test coverage for LITERALMATCH constant and literal type parsing
- Fixes parsing inconsistency between YARD TypesExplainer and online parser

Resolves #1627

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: lekemula

lib/yard/code_objects/base.rb

@@ -63,6 +63,9 @@ def push(value)
     # Regular expression to match a fully qualified method def (self.foo, Class.foo).
     METHODMATCH = /(?:(?:#{NAMESPACEMATCH}|[a-z]\w*)\s*(?:#{CSEPQ}|#{NSEPQ})\s*)?#{METHODNAMEMATCH}/
 
+    # Regular expression to match symbol and string literals
+    LITERALMATCH = /:\w+|'[^']*'|"[^"]*"/
+
     # All builtin Ruby exception classes for inheritance tree.
     BUILTIN_EXCEPTIONS = ["ArgumentError", "ClosedQueueError", "EncodingError",
       "EOFError", "Exception", "FiberError", "FloatDomainError", "IndexError",

lib/yard/tags/types_explainer.rb

@@ -33,6 +33,8 @@ def initialize(name)
         def to_s(singular = true)
           if name[0, 1] == "#"
             singular ? "an object that responds to #{name}" : "objects that respond to #{name}"
+          elsif name[0, 1] == ":" || (name[0, 1] =~ /['"]/ && name[-1, 1] =~ /['"]/)
+            "a literal value #{name}"
           elsif name[0, 1] =~ /[A-Z]/
             singular ? "a#{name[0, 1] =~ /[aeiou]/i ? 'n' : ''} " + name : "#{name}#{name[-1, 1] =~ /[A-Z]/ ? "'" : ''}s"
           else
@@ -101,7 +103,7 @@ class Parser
           :collection_end => />/,
           :fixed_collection_start => /\(/,
           :fixed_collection_end => /\)/,
-          :type_name => /#{ISEP}#{METHODNAMEMATCH}|#{NAMESPACEMATCH}|\w+/,
+          :type_name => /#{ISEP}#{METHODNAMEMATCH}|#{NAMESPACEMATCH}|#{LITERALMATCH}|\w+/,
           :type_next => /[,;]/,
           :whitespace => /\s+/,
           :hash_collection_start => /\{/,

spec/code_objects/constants_spec.rb

@@ -56,6 +56,26 @@ def silence_warnings
     end
   end
 
+  describe :LITERALMATCH do
+    it "matches symbol literals" do
+      expect(":symbol"[CodeObjects::LITERALMATCH]).to eq ":symbol"
+      expect(":some_symbol"[CodeObjects::LITERALMATCH]).to eq ":some_symbol"
+      expect("not_a_symbol"[CodeObjects::LITERALMATCH]).to be nil
+    end
+
+    it "matches single-quoted string literals" do
+      expect("'string'"[CodeObjects::LITERALMATCH]).to eq "'string'"
+      expect("'some string with spaces'"[CodeObjects::LITERALMATCH]).to eq "'some string with spaces'"
+      expect("not_quoted"[CodeObjects::LITERALMATCH]).to be nil
+    end
+
+    it "matches double-quoted string literals" do
+      expect('"string"'[CodeObjects::LITERALMATCH]).to eq '"string"'
+      expect('"some string with spaces"'[CodeObjects::LITERALMATCH]).to eq '"some string with spaces"'
+      expect("not_quoted"[CodeObjects::LITERALMATCH]).to be nil
+    end
+  end
+
   describe :BUILTIN_EXCEPTIONS do
     it "includes all base exceptions" do
       bad_names = []

spec/tags/types_explainer_spec.rb

@@ -45,6 +45,14 @@ def parse_fail(types)
         expect(@t.to_s(false)).to eq name
       end
     end
+
+    it "works for literal values" do
+      [':symbol', "'5'"].each do |name|
+        @t.name = name
+        expect(@t.to_s).to eq "a literal value #{name}"
+        expect(@t.to_s(false)).to eq "a literal value #{name}"
+      end
+    end
   end
 
   describe CollectionType, '#to_s' do
@@ -131,6 +139,17 @@ def parse_fail(types)
       expect(type[3].name).to eq "E"
     end
 
+    it 'parses a list of literal values' do
+      type = parse("true, false, nil, 4, :symbol, '5'")
+      expect(type.size).to eq 6
+      expect(type[0].name).to eq "true"
+      expect(type[1].name).to eq "false"
+      expect(type[2].name).to eq "nil"
+      expect(type[3].name).to eq "4"
+      expect(type[4].name).to eq ":symbol"
+      expect(type[5].name).to eq "'5'"
+    end
+
     it "parses a collection type" do
       type = parse("MyList<String>")
       expect(type.first).to be_a(CollectionType)
@@ -192,7 +211,8 @@ def parse_fail(types)
           a Hash with keys made of (Foos or Bars) and values of (Symbols or Numbers)",
         "#weird_method?, #<=>, #!=" => "an object that responds to #weird_method?;
           an object that responds to #<=>;
-          an object that responds to #!="
+          an object that responds to #!=",
+        ":symbol, 'string'" => "a literal value :symbol; a literal value 'string'"
       }
       expect.each do |input, expected|
         explain = YARD::Tags::TypesExplainer.explain(input)