Rename (Tagged → Annotated)String, etc.

Please, please, let this be the last rename.

NEWS.md

@@ -8,11 +8,11 @@ New language features
   difference between `public` and `export` is that `public` names do not become
   available when `using` a package/module. ([#50105])
 * `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
-* A new `AbstractString` type, `TaggedString`, is introduced that allows for
-  (arbitrary) regional annotations to be attached to an underlying string. This is
-  very useful for allowing styling information to be encoded separately, and is
-  used extensively in the new `StyledStrings` standard library. There is also a
-  new `TaggedChar` type, that is the equivalent new `AbstractChar` type.
+* A new `AbstractString` type, `AnnotatedString`, is introduced that allows for
+  regional annotations to be attached to an underlying string. This type is
+  particularly useful for holding styling information, and is used extensively
+  in the new `StyledStrings` standard library. There is also a new `AnnotatedChar`
+  type, that is the equivalent new `AbstractChar` type.
 
 Language changes
 ----------------
@@ -60,11 +60,12 @@ Standard library changes
 
 * A new standard library for handling styling in a more comprehensive and structured way.
 * The new `Faces` struct serves as a container for text styling information
-  (think typeface), and comes with a framework to provide a convenient,
-  extensible (via `addface!`), and customisable (with a user's `Faces.toml` and `loadfaces!`) approach to
+  (think typeface, as well as color and decoration), and comes with a framework
+  to provide a convenient, extensible (via `addface!`), and customisable (with a
+  user's `Faces.toml` and `loadfaces!`) approach to
   styled content.
 * The new `@styled_str` string macro provides a convenient way of creating a
-  `TaggedString` with various faces or other attributes applied.
+  `AnnotatedString` with various faces or other attributes applied.
 
 #### Package Manager
 

base/exports.jl

@@ -1089,12 +1089,12 @@ public
     Generator,
     ImmutableDict,
     OneTo,
-    TaggedString,
-    TaggedChar,
+    AnnotatedString,
+    AnnotatedChar,
     UUID,
 
-# Tagged strings
-    taggedstring,
+# Annotated strings
+    annotatedstring,
     annotate!,
     annotations,
 

base/regex.jl

@@ -427,35 +427,35 @@ function match(re::Regex, str::Union{SubString{String}, String}, idx::Integer,
     return result
 end
 
-function _taggedmatch(m::RegexMatch{S}, str::TaggedString{S}) where {S<:AbstractString}
-    RegexMatch{TaggedString{S}}(
-        (@inbounds SubString{TaggedString{S}}(
+function _annotatedmatch(m::RegexMatch{S}, str::AnnotatedString{S}) where {S<:AbstractString}
+    RegexMatch{AnnotatedString{S}}(
+        (@inbounds SubString{AnnotatedString{S}}(
             str, m.match.offset, m.match.ncodeunits, Val(:noshift))),
-        Union{Nothing,SubString{TaggedString{S}}}[
+        Union{Nothing,SubString{AnnotatedString{S}}}[
             if !isnothing(cap)
-                (@inbounds SubString{TaggedString{S}}(
+                (@inbounds SubString{AnnotatedString{S}}(
                     str, cap.offset, cap.ncodeunits, Val(:noshift)))
             end for cap in m.captures],
         m.offset, m.offsets, m.regex)
 end
 
-function match(re::Regex, str::TaggedString)
+function match(re::Regex, str::AnnotatedString)
     m = match(re, str.string)
     if !isnothing(m)
-        _taggedmatch(m, str)
+        _annotatedmatch(m, str)
     end
 end
 
-function match(re::Regex, str::TaggedString, idx::Integer, add_opts::UInt32=UInt32(0))
+function match(re::Regex, str::AnnotatedString, idx::Integer, add_opts::UInt32=UInt32(0))
     m = match(re, str.string, idx, add_opts)
     if !isnothing(m)
-        _taggedmatch(m, str)
+        _annotatedmatch(m, str)
     end
 end
 
 match(r::Regex, s::AbstractString) = match(r, s, firstindex(s))
 match(r::Regex, s::AbstractString, i::Integer) = throw(ArgumentError(
-    "regex matching is only available for the String and TaggedString types; use String(s) to convert"
+    "regex matching is only available for the String and AnnotatedString types; use String(s) to convert"
 ))
 
 findnext(re::Regex, str::Union{String,SubString}, idx::Integer) = _findnext_re(re, str, idx, C_NULL)
@@ -708,8 +708,8 @@ struct RegexMatchIterator{S <: AbstractString}
 
     RegexMatchIterator(regex::Regex, string::AbstractString, ovr::Bool=false) =
         new{String}(regex, String(string), ovr)
-    RegexMatchIterator(regex::Regex, string::TaggedString, ovr::Bool=false) =
-        new{TaggedString{String}}(regex, TaggedString(String(string.string), string.annotations), ovr)
+    RegexMatchIterator(regex::Regex, string::AnnotatedString, ovr::Bool=false) =
+        new{AnnotatedString{String}}(regex, AnnotatedString(String(string.string), string.annotations), ovr)
 end
 compile(itr::RegexMatchIterator) = (compile(itr.regex); itr)
 eltype(::Type{<:RegexMatchIterator}) = RegexMatch