Dates: remove anti-pattern of using Tuple{Union{Nothing, Something}, Int}

While the new optimizer should handle this better,
the optimal efficient way to handle this is to make the missingness entirely disjoin:
`Union{Nothing, Tuple{Something, Int}}`

And make each `val` variable SSA, for better inference

Author: vtjnash

stdlib/Dates/src/io.jl

@@ -17,11 +17,10 @@ abstract type AbstractDateToken end
 `locale`. If a `tryparsenext` method does not need a locale, it can leave
 the argument out in the method definition.
 
-Return a tuple of 2 elements `(res, idx)`, where:
+If parsing succeeds, returns a tuple of 2 elements `(res, idx)`, where:
 
-* `res` is either the result of the parsing, or `nothing` if parsing failed.
-* `idx` is an `Int` - if parsing failed, the index at which it failed; if
-   parsing succeeded, `idx` is the index _after_ the index at which parsing ended.
+* `res` is the result of the parsing.
+* `idx::Int`, is the index _after_ the index at which parsing ended.
 """
 function tryparsenext end
 
@@ -39,7 +38,7 @@ function format end
 
 # fallback to tryparsenext/format methods that don't care about locale
 @inline function tryparsenext(d::AbstractDateToken, str, i, len, locale)
-    tryparsenext(d, str, i, len)
+    return tryparsenext(d, str, i, len)
 end
 
 function Base.string(t::Time)
@@ -91,38 +90,35 @@ end
 for c in "yYmdHMS"
     @eval begin
         @inline function tryparsenext(d::DatePart{$c}, str, i, len)
-            tryparsenext_base10(str, i, len, min_width(d), max_width(d))
+            return tryparsenext_base10(str, i, len, min_width(d), max_width(d))
         end
     end
 end
 
 for (tok, fn) in zip("uUeE", [monthabbr_to_value, monthname_to_value, dayabbr_to_value, dayname_to_value])
     @eval @inline function tryparsenext(d::DatePart{$tok}, str, i, len, locale)
-        word, i = tryparsenext_word(str, i, len, locale, max_width(d))
-        val = word === nothing ? 0 : $fn(word, locale)
-        if val == 0
-            return nothing, i
-        else
-            return val, i
-        end
+        next = tryparsenext_word(str, i, len, locale, max_width(d))
+        next === nothing && return nothing
+        word, i = next
+        val = $fn(word, locale)
+        val == 0 && return nothing
+        return val, i
     end
 end
 
 # 3-digit (base 10) number following a decimal point. For InexactError below.
 struct Decimal3 end
 
 @inline function tryparsenext(d::DatePart{'s'}, str, i, len)
-    ms, ii = tryparsenext_base10(str, i, len, min_width(d), max_width(d))
-    if ms !== nothing
-        val0 = val = ms
-        len = ii - i
-        if len > 3
-            val, r = divrem(val, Int64(10) ^ (len - 3))
-            r == 0 || throw(InexactError(:convert, Decimal3, val0))
-        else
-            val *= Int64(10) ^ (3 - len)
-        end
-        ms = val
+    val = tryparsenext_base10(str, i, len, min_width(d), max_width(d))
+    val === nothing && return nothing
+    ms0, ii = val
+    len = ii - i
+    if len > 3
+        ms, r = divrem(ms0, Int64(10) ^ (len - 3))
+        r == 0 || throw(InexactError(:convert, Decimal3, ms0))
+    else
+        ms = ms0 * Int64(10) ^ (3 - len)
     end
     return ms, ii
 end
@@ -186,10 +182,10 @@ Delim(d::T) where {T<:AbstractChar} = Delim{T, 1}(d)
 Delim(d::String) = Delim{String, length(d)}(d)
 
 @inline function tryparsenext(d::Delim{<:AbstractChar, N}, str, i::Int, len) where N
-    for j=1:N
-        i > len && return (nothing, i)
+    for j = 1:N
+        i > len && return nothing
         c, i = next(str, i)
-        c != d.d && return (nothing, i)
+        c != d.d && return nothing
     end
     return true, i
 end
@@ -199,12 +195,12 @@ end
     i2 = start(d.d)
     for j = 1:N
         if i1 > len
-            return nothing, i1
+            return nothing
         end
         c1, i1 = next(str, i1)
         c2, i2 = next(d.d, i2)
         if c1 != c2
-            return nothing, i1
+            return nothing
         end
     end
     return true, i1

stdlib/Dates/src/parse.jl

@@ -23,11 +23,11 @@ genvar(t::DataType) = Symbol(lowercase(string(nameof(t))))
 
 Parse the string according to the directives within the `DateFormat`. Parsing will start at
 character index `pos` and will stop when all directives are used or we have parsed up to
-the end of the string, `len`. When a directive cannot be parsed the returned value tuple
+the end of the string, `len`. When a directive cannot be parsed the returned value
 will be `nothing` if `raise` is false otherwise an exception will be thrown.
 
-Return a 3-element tuple `(values, pos, num_parsed)`:
-* `values::Union{Tuple, Nothing}`: Either `nothing`, or a tuple which contains a value
+If successful, return a 3-element tuple `(values, pos, num_parsed)`:
+* `values::Tuple`: A tuple which contains a value
   for each `DatePart` within the `DateFormat` in the order
   in which they occur. If the string ends before we finish parsing all the directives
   the missing values will be filled in with default values.
@@ -58,29 +58,30 @@ Return a 3-element tuple `(values, pos, num_parsed)`:
     for i = 1:length(directives)
         if directives[i] <: DatePart
             name = value_names[vi]
-            val = Symbol(:val, name)
             vi += 1
             push!(parsers, quote
                 pos > len && @goto done
-                $val, next_pos = tryparsenext(directives[$i], str, pos, len, locale)
-                $val === nothing && @goto error
-                $name = $val
-                pos = next_pos
+                local $name
+                let val = tryparsenext(directives[$i], str, pos, len, locale)
+                    val === nothing && @goto error
+                    $name, pos = val
+                end
                 num_parsed += 1
                 directive_index += 1
             end)
         else
             push!(parsers, quote
                 pos > len && @goto done
-                delim, next_pos = tryparsenext(directives[$i], str, pos, len, locale)
-                delim === nothing && @goto error
-                pos = next_pos
+                let val = tryparsenext(directives[$i], str, pos, len, locale)
+                    val === nothing && @goto error
+                    delim, pos = val
+                end
                 directive_index += 1
             end)
         end
     end
 
-    quote
+    return quote
         directives = df.tokens
         locale::DateLocale = df.locale
 
@@ -104,7 +105,7 @@ Return a 3-element tuple `(values, pos, num_parsed)`:
                 throw(ArgumentError("Unable to parse date time. Expected directive $d at char $pos"))
             end
         end
-        return nothing, pos, 0
+        return nothing
     end
 end
 
@@ -114,11 +115,11 @@ end
 Parse the string according to the directives within the `DateFormat`. The specified `TimeType`
 type determines the type of and order of tokens returned. If the given `DateFormat` or string
 does not provide a required token a default value will be used. When the string cannot be
-parsed the returned value tuple will be `nothing` if `raise` is false otherwise an exception will
+parsed the returned value will be `nothing` if `raise` is false otherwise an exception will
 be thrown.
 
-Return a 2-element tuple `(values, pos)`:
-* `values::Union{Tuple, Nothing}`: Either `nothing`, or a tuple which contains a value
+If successful, returns a 2-element tuple `(values, pos)`:
+* `values::Tuple`: A tuple which contains a value
   for each token as specified by the passed in type.
 * `pos::Int`: The character index at which parsing stopped.
 """
@@ -146,17 +147,18 @@ Return a 2-element tuple `(values, pos)`:
     # Unpacks the value tuple returned by `tryparsenext_core` into separate variables.
     value_tuple = Expr(:tuple, value_names...)
 
-    quote
-        values, pos, num_parsed = tryparsenext_core(str, pos, len, df, raise)
-        values === nothing && return nothing, pos
+    return quote
+        val = tryparsenext_core(str, pos, len, df, raise)
+        val === nothing && return nothing
+        values, pos, num_parsed = val
         $(assign_defaults...)
         $value_tuple = values
         return $(Expr(:tuple, output_names...)), pos
     end
 end
 
 @inline function tryparsenext_base10(str::AbstractString, i::Int, len::Int, min_width::Int=1, max_width::Int=0)
-    i > len && (return nothing, i)
+    i > len && return nothing
     min_pos = min_width <= 0 ? i : i + min_width - 1
     max_pos = max_width <= 0 ? len : min(i + max_width - 1, len)
     d::Int64 = 0
@@ -170,7 +172,7 @@ end
         i = ii
     end
     if i <= min_pos
-        return nothing, i
+        return nothing
     else
         return d, i
     end
@@ -189,7 +191,7 @@ end
         i = ii
     end
     if word_end == 0
-        return nothing, i
+        return nothing
     else
         return SubString(str, word_start, word_end), i
     end
@@ -198,60 +200,75 @@ end
 function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeFormat))
     i, end_pos = firstindex(s), lastindex(s)
 
+    local dy
     dm = dd = Int64(1)
     th = tm = ts = tms = Int64(0)
 
-    val, i = tryparsenext_base10(s, i, end_pos, 1)
-    dy = val === nothing ? (@goto error) : val
-    i > end_pos && @goto error
+    let val = tryparsenext_base10(s, i, end_pos, 1)
+        val === nothing && @goto error
+        dy, i = val
+        i > end_pos && @goto error
+    end
 
     c, i = next(s, i)
     c != '-' && @goto error
     i > end_pos && @goto done
 
-    val, i = tryparsenext_base10(s, i, end_pos, 1, 2)
-    dm = val === nothing ? (@goto error) : val
-    i > end_pos && @goto done
+    let val = tryparsenext_base10(s, i, end_pos, 1, 2)
+        val === nothing && @goto error
+        dm, i = val
+        i > end_pos && @goto done
+    end
 
     c, i = next(s, i)
     c != '-' && @goto error
     i > end_pos && @goto done
 
-    val, i = tryparsenext_base10(s, i, end_pos, 1, 2)
-    dd = val === nothing ? (@goto error) : val
-    i > end_pos && @goto done
+    let val = tryparsenext_base10(s, i, end_pos, 1, 2)
+        val === nothing && @goto error
+        dd, i = val
+        i > end_pos && @goto done
+    end
 
     c, i = next(s, i)
     c != 'T' && @goto error
     i > end_pos && @goto done
 
-    val, i = tryparsenext_base10(s, i, end_pos, 1, 2)
-    th = val === nothing ? (@goto error) : val
-    i > end_pos && @goto done
+    let val = tryparsenext_base10(s, i, end_pos, 1, 2)
+        val === nothing && @goto error
+        th, i = val
+        i > end_pos && @goto done
+    end
 
     c, i = next(s, i)
     c != ':' && @goto error
     i > end_pos && @goto done
 
-    val, i = tryparsenext_base10(s, i, end_pos, 1, 2)
-    tm = val === nothing ? (@goto error) : val
-    i > end_pos && @goto done
+    let val = tryparsenext_base10(s, i, end_pos, 1, 2)
+        val === nothing && @goto error
+        tm, i = val
+        i > end_pos && @goto done
+    end
 
     c, i = next(s, i)
     c != ':' && @goto error
     i > end_pos && @goto done
 
-    val, i = tryparsenext_base10(s, i, end_pos, 1, 2)
-    ts = val === nothing ? (@goto error) : val
-    i > end_pos && @goto done
+    let val = tryparsenext_base10(s, i, end_pos, 1, 2)
+        val === nothing && @goto error
+        ts, i = val
+        i > end_pos && @goto done
+    end
 
     c, i = next(s, i)
     c != '.' && @goto error
     i > end_pos && @goto done
 
-    val, j = tryparsenext_base10(s, i, end_pos, 1, 3)
-    tms = val === nothing ? (@goto error) : val
-    tms *= 10 ^ (3 - (j - i))
+    let val = tryparsenext_base10(s, i, end_pos, 1, 3)
+        val === nothing && @goto error
+        tms, j = val
+        tms *= 10 ^ (3 - (j - i))
+    end
 
     j > end_pos || @goto error
 
@@ -264,21 +281,22 @@ end
 
 function Base.parse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType
     pos, len = firstindex(str), lastindex(str)
-    values, pos = tryparsenext_internal(T, str, pos, len, df, true)
-    T(values...)
+    val = tryparsenext_internal(T, str, pos, len, df, true)
+    @assert val !== nothing
+    values, endpos = val
+    return T(values...)
 end
 
 function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType
     pos, len = firstindex(str), lastindex(str)
-    values, pos = tryparsenext_internal(T, str, pos, len, df, false)
-    if values === nothing
-        nothing
-    elseif validargs(T, values...) === nothing
+    res = tryparsenext_internal(T, str, pos, len, df, false)
+    res === nothing && return nothing
+    values, endpos = res
+    if validargs(T, values...) === nothing
         # TODO: validargs gets called twice, since it's called again in the T constructor
-        T(values...)
-    else
-        nothing
+        return T(values...)
     end
+    return nothing
 end
 
 """
@@ -293,15 +311,16 @@ number of components may be less than the total number of `DatePart`.
     letters = character_codes(df)
     tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]
 
-    quote
+    return quote
         pos, len = firstindex(str), lastindex(str)
-        values, pos, num_parsed = tryparsenext_core(str, pos, len, df, true)
-        t = values
+        val = tryparsenext_core(str, pos, len, df, #=raise=#true)
+        @assert val !== nothing
+        values, pos, num_parsed = val
         types = $(Expr(:tuple, tokens...))
         result = Vector{Any}(undef, num_parsed)
         for (i, typ) in enumerate(types)
             i > num_parsed && break
-            result[i] = typ(t[i])  # Constructing types takes most of the time
+            result[i] = typ(values[i])  # Constructing types takes most of the time
         end
         return result
     end

stdlib/Dates/test/io.jl

@@ -390,7 +390,7 @@ end
     Zulu = String
 
     function Dates.tryparsenext(d::Dates.DatePart{'Z'}, str, i, len)
-        Dates.tryparsenext_word(str, i, len, Dates.min_width(d), Dates.max_width(d))
+        return Dates.tryparsenext_word(str, i, len, Dates.min_width(d), Dates.max_width(d))
     end
 
     str = "2015-07-24T05:38:19.591Z"