Use a macro to avoid runtime eval

This should be a bit better in terms of codegen.

Author: tecosaur

src/io.jl

@@ -248,7 +248,7 @@ function _ansi_writer(io::IO, s::Union{<:AnnotatedString, SubString{<:AnnotatedS
         string_writer(io, s.string)
     elseif s isa SubString
         string_writer(
-            io, eval(Expr(:new, SubString{typeof(s.string.string)}, s.string.string, s.offset, s.ncodeunits)))
+            io, AnnotatedStrings.@raw_substring(typeof(s.string.string), s.string.string, s.offset, s.ncodeunits))
     end
 end
 

src/strings/annotated.jl

@@ -206,16 +206,16 @@ cmp(a::AnnotatedString, b::AnnotatedString) = cmp(a.string, b.string)
 # To prevent substring equality from hitting the generic fallback
 
 function ==(a::SubString{<:AnnotatedString}, b::SubString{<:AnnotatedString})
-    eval(Expr(:new, SubString{typeof(a.string.string)}, a.string.string, a.offset, a.ncodeunits)) ==
-        eval(Expr(:new, SubString{typeof(b.string.string)}, b.string.string, b.offset, b.ncodeunits)) &&
+    @raw_substring(typeof(a.string.string), a.string.string, a.offset, a.ncodeunits) ==
+        @raw_substring(typeof(b.string.string), b.string.string, b.offset, b.ncodeunits) &&
         annotations(a) == annotations(b)
 end
 
 ==(a::SubString{<:AnnotatedString}, b::AnnotatedString) =
-    annotations(a) == annotations(b) && eval(Expr(:new, SubString{typeof(a.string.string)}, a.string.string, a.offset, a.ncodeunits)) == b.string
+    annotations(a) == annotations(b) && @raw_substring(typeof(a.string.string), a.string.string, a.offset, a.ncodeunits) == b.string
 
 ==(a::SubString{<:AnnotatedString}, b::AbstractString) =
-    isempty(annotations(a)) && eval(Expr(:new, SubString{typeof(a.string.string)}, a.string.string, a.offset, a.ncodeunits)) == b
+    isempty(annotations(a)) && @raw_substring(typeof(a.string.string), a.string.string, a.offset, a.ncodeunits) == b
 
 ==(a::AbstractString, b::SubString{<:AnnotatedString}) = b == a
 
@@ -264,7 +264,7 @@ function annotatedstring(xs...)
                     push!(annotations, (rstart:rstop, annot))
                 end
             end
-            print(s, eval(Expr(:new, SubString{typeof(x.string.string)}, x.string.string, x.offset, x.ncodeunits)))
+            print(s, @raw_substring(typeof(x.string.string), x.string.string, x.offset, x.ncodeunits))
         elseif x isa AnnotatedChar
             for annot in x.annotations
                 push!(annotations, (1+size:1+size, annot))

src/strings/regex.jl

@@ -20,14 +20,11 @@ end
 
 function _annotatedmatch(m::RegexMatch, str::AnnotatedString{S}) where {S<:AbstractString}
     AnnotatedRegexMatch{AnnotatedString{S}}(
-        # It's surprisingly annoying to clone a substring,
-        # thanks to that pesky inner constructor.
-        eval(Expr(:new, SubString{AnnotatedString{S}}(
-            str, m.match.offset, m.match.ncodeunits))),
+        @raw_substring(AnnotatedString{S}, str, m.match.offset, m.match.ncodeunits),
         Union{Nothing,SubString{AnnotatedString{S}}}[
             if !isnothing(cap)
-                eval(Expr(:new, SubString{AnnotatedString{S}}(
-                    str, cap.offset, cap.ncodeunits)))
+                @raw_substring(AnnotatedString{S},
+                               str, cap.offset, cap.ncodeunits)
             end for cap in m.captures],
         m.offset, m.offsets, m.regex)
 end

src/strings/strings.jl

@@ -11,6 +11,12 @@ import Base: @propagate_inbounds, AbstractPipe, TTY, String, cmp, codepoint,
 
 using ..Compat
 
+# It's surprisingly annoying to clone a substring,
+# thanks to that pesky inner constructor.
+macro raw_substring(T, str, offset, ncu)
+    esc(Expr(:new, Expr(:curly, :SubString, T), str, offset, ncu))
+end
+
 include(joinpath(dirname(@__DIR__), "compat.jl"))
 include("annotated.jl")