#37859

Committed 03 Aug 2024 02:29AM UTC coverage: 86.711% (-0.8%) from 87.527%

Build # #37859

Build Type

push

local

Committed by

web-flow

Commit Message

Profile: close files when assembling heap snapshot (#55356)

Run Details

28 of 28 new or added lines in 1 file covered. (100.0%)

1106 existing lines in 35 files now uncovered.

76980 of 88778 relevant lines covered (86.71%)

15372587.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.85

/stdlib/Dates/src/parse.jl

# This file is a part of Julia. License is MIT: https://julialang.org/license

### Parsing utilities

_directives(::Type{DateFormat{S,T}}) where {S,T} = T.parameters

character_codes(df::Type{DateFormat{S,T}}) where {S,T} = character_codes(_directives(df))
function character_codes(directives::Core.SimpleVector)
    letters = sizehint!(Char[], length(directives))
    for (i, directive) in enumerate(directives)
        if directive <: DatePart
            letter = first(directive.parameters)
            push!(letters, letter)
        end
    end
    return letters
end

genvar(t::DataType) = Symbol(lowercase(string(nameof(t))))

"""
    tryparsenext_core(str::AbstractString, pos::Int, len::Int, df::DateFormat, raise=false)

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
will be `nothing` if `raise` is false otherwise an exception will be thrown.

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.
* `pos::Int`: The character index at which parsing stopped.
* `num_parsed::Int`: The number of values which were parsed and stored within `values`.
  Useful for distinguishing parsed values from default values.
"""
@generated function tryparsenext_core(str::AbstractString, pos::Int, len::Int,
                                      df::DateFormat, raise::Bool=false)
    directives = _directives(df)
    letters = character_codes(directives)

    tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]
    value_names = Symbol[genvar(t) for t in tokens]
    value_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in tokens)

    # Pre-assign variables to defaults. Allows us to use `@goto done` without worrying about
    # unassigned variables.
    assign_defaults = Expr[]
    for (name, default) in zip(value_names, value_defaults)
        push!(assign_defaults, quote
            $name = $default
        end)
    end

    vi = 1
    parsers = Expr[]
    for i = 1:length(directives)
        if directives[i] <: DatePart
            name = value_names[vi]
            vi += 1
            push!(parsers, quote
                pos > len && @goto done
                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
                let val = tryparsenext(directives[$i], str, pos, len, locale)
                    val === nothing && @goto error
                    delim, pos = val
                end
                directive_index += 1
            end)
        end
    end

    return quote
        directives = df.tokens
        locale::DateLocale = df.locale

        num_parsed = 0
        directive_index = 1

        $(assign_defaults...)
        $(parsers...)

        pos > len || @goto error

        @label done
        return $(Expr(:tuple, value_names...)), pos, num_parsed

        @label error
        if raise
            if directive_index > length(directives)
                throw(ArgumentError("Found extra characters at the end of date time string"))
            else
                d = directives[directive_index]
                throw(ArgumentError("Unable to parse date time. Expected directive $d at char $pos"))
            end
        end
        return nothing
    end
end

"""
    tryparsenext_internal(::Type{<:TimeType}, str, pos, len, df::DateFormat, raise=false)

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 will be `nothing` if `raise` is false otherwise an exception will
be thrown.

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.
"""
@generated function tryparsenext_internal(::Type{T}, str::AbstractString, pos::Int, len::Int,
                                          df::DateFormat, raise::Bool=false) where T<:TimeType
    letters = character_codes(df)

    tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]
    value_names = Symbol[genvar(t) for t in tokens]

    output_tokens = CONVERSION_TRANSLATIONS[T]
    output_names = Symbol[genvar(t) for t in output_tokens]
    output_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in output_tokens)

    # Pre-assign output variables to defaults. Ensures that all output variables are
    # assigned as the value tuple returned from `tryparsenext_core` may not include all
    # of the required variables.
    assign_defaults = Expr[
        quote
            $name = $default
        end
        for (name, default) in zip(output_names, output_defaults)
    ]

    # Unpacks the value tuple returned by `tryparsenext_core` into separate variables.
    value_tuple = Expr(:tuple, value_names...)

    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_sign(str::AbstractString, i::Int, len::Int)
    i > len && return nothing
    c, ii = iterate(str, i)::Tuple{Char, Int}
    if c == '+'
        return 1, ii
    elseif c == '-'
        return -1, ii
    else
        return nothing
    end
end

@inline function tryparsenext_base10(str::AbstractString, i::Int, len::Int, min_width::Int=1, max_width::Int=0)
    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
    @inbounds while i <= max_pos
        c, ii = iterate(str, i)::Tuple{Char, Int}
        if '0' <= c <= '9'
            d = d * 10 + (c - '0')
        else
            break
        end
        i = ii
    end
    if i <= min_pos
        return nothing
    else
        return d, i
    end
end

@inline function tryparsenext_word(str::AbstractString, i, len, locale, maxchars=0)
    word_start, word_end = i, 0
    max_pos = maxchars <= 0 ? len : min(len, nextind(str, i, maxchars-1))
    @inbounds while i <= max_pos
        c, ii = iterate(str, i)::Tuple{Char, Int}
        if isletter(c)
            word_end = i
        else
            break
        end
        i = ii
    end
    if word_end == 0
        return nothing
    else
        return SubString(str, word_start, word_end), i
    end
end

function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeFormat))
    i, end_pos = firstindex(s), lastindex(s)
    i > end_pos && throw(ArgumentError("Cannot parse an empty string as a DateTime"))

    coefficient = 1
    local dy
    dm = dd = Int64(1)
    th = tm = ts = tms = Int64(0)

    # Optional sign
    let val = tryparsenext_sign(s, i, end_pos)
        if val !== nothing
            coefficient, i = val
        end
    end

    let val = tryparsenext_base10(s, i, end_pos, 1)
        val === nothing && @goto error
        dy, i = val
        i > end_pos && @goto done
    end

    c, i = iterate(s, i)::Tuple{Char, Int}
    c != '-' && @goto error
    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 = iterate(s, i)::Tuple{Char, Int}
    c != '-' && @goto error
    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 = iterate(s, i)::Tuple{Char, Int}
    c != 'T' && @goto error
    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 = iterate(s, i)::Tuple{Char, Int}
    c != ':' && @goto error
    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 = iterate(s, i)::Tuple{Char, Int}
    c != ':' && @goto error
    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 = iterate(s, i)::Tuple{Char, Int}
    c != '.' && @goto error
    i > end_pos && @goto done

    let val = tryparsenext_base10(s, i, end_pos, 1, 3)
        val === nothing && @goto error
        tms, j = val
        tms *= 10 ^ (3 - (j - i))
        j > end_pos || @goto error
    end

    @label done
    return DateTime(dy * coefficient, dm, dd, th, tm, ts, tms)

    @label error
    throw(ArgumentError("Invalid DateTime string"))
end

function Base.parse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType
    pos, len = firstindex(str), lastindex(str)
    pos > len && throw(ArgumentError("Cannot parse an empty string as a Date or Time"))
    val = tryparsenext_internal(T, str, pos, len, df, true)
    @assert val !== nothing
    values, endpos = val
    return T(values...)::T
end

function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType
    pos, len = firstindex(str), lastindex(str)
    pos > len && return 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
        return T(values...)::T
    end
    return nothing
end

"""
    parse_components(str::AbstractString, df::DateFormat) -> Array{Any}

Parse the string into its components according to the directives in the `DateFormat`.
Each component will be a distinct type, typically a subtype of Period. The order of the
components will match the order of the `DatePart` directives within the `DateFormat`. The
number of components may be less than the total number of `DatePart`.
"""
@generated function parse_components(str::AbstractString, df::DateFormat)
    letters = character_codes(df)
    tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]

    return quote
        pos, len = firstindex(str), lastindex(str)
        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(values[i])  # Constructing types takes most of the time
        end
        return result
    end
end

1	# This file is a part of Julia. License is MIT: https://julialang.org/license
2
3	### Parsing utilities
4
5	_directives(::Type{DateFormat{S,T}}) where {S,T} = T.parameters	244✔
6
7	character_codes(df::Type{DateFormat{S,T}}) where {S,T} = character_codes(_directives(df))	166✔
8	function character_codes(directives::Core.SimpleVector)	244✔
9	letters = sizehint!(Char[], length(directives))	244✔
10	for (i, directive) in enumerate(directives)	488✔
11	if directive <: DatePart	1,512✔
12	letter = first(directive.parameters)	913✔
13	push!(letters, letter)	913✔
14	end
15	end	2,780✔
16	return letters	244✔
17	end
18
19	genvar(t::DataType) = Symbol(lowercase(string(nameof(t))))	1,938✔
20
21	"""
22	tryparsenext_core(str::AbstractString, pos::Int, len::Int, df::DateFormat, raise=false)
23
24	Parse the string according to the directives within the `DateFormat`. Parsing will start at
25	character index `pos` and will stop when all directives are used or we have parsed up to
26	the end of the string, `len`. When a directive cannot be parsed the returned value
27	will be `nothing` if `raise` is false otherwise an exception will be thrown.
28
29	If successful, return a 3-element tuple `(values, pos, num_parsed)`:
30	* `values::Tuple`: A tuple which contains a value
31	for each `DatePart` within the `DateFormat` in the order
32	in which they occur. If the string ends before we finish parsing all the directives
33	the missing values will be filled in with default values.
34	* `pos::Int`: The character index at which parsing stopped.
35	* `num_parsed::Int`: The number of values which were parsed and stored within `values`.
36	Useful for distinguishing parsed values from default values.
37	"""
38	@generated function tryparsenext_core(str::AbstractString, pos::Int, len::Int,	237✔
39	df::DateFormat, raise::Bool=false)
40	directives = _directives(df)	78✔
41	letters = character_codes(directives)	78✔
42
43	tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]	78✔
44	value_names = Symbol[genvar(t) for t in tokens]	78✔
45	value_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in tokens)	78✔
46
47	# Pre-assign variables to defaults. Allows us to use `@goto done` without worrying about
48	# unassigned variables.
49	assign_defaults = Expr[]	78✔
50	for (name, default) in zip(value_names, value_defaults)	156✔
51	push!(assign_defaults, quote	295✔
52	$name = $default	237✔
53	end)
54	end	512✔
55
56	vi = 1	78✔
57	parsers = Expr[]	78✔
58	for i = 1:length(directives)	78✔
59	if directives[i] <: DatePart	491✔
60	name = value_names[vi]	295✔
61	vi += 1	295✔
62	push!(parsers, quote	295✔
63	pos > len && @goto done	746✔
64	let val = tryparsenext(directives[$i], str, pos, len, locale)	1,407✔
65	val === nothing && @goto error	743✔
66	$name, pos = val	732✔
67	end
68	num_parsed += 1	732✔
69	directive_index += 1	732✔
70	end)
71	else
72	push!(parsers, quote	196✔
73	pos > len && @goto done	498✔
74	let val = tryparsenext(directives[$i], str, pos, len, locale)	970✔
75	val === nothing && @goto error	478✔
76	delim, pos = val	463✔
77	end
78	directive_index += 1	463✔
79	end)
80	end
81	end	491✔
82
83	return quote	78✔
84	directives = df.tokens	237✔
85	locale::DateLocale = df.locale	237✔
86
87	num_parsed = 0	237✔
88	directive_index = 1	237✔
89
90	$(assign_defaults...)
91	$(parsers...)
92
93	pos > len \|\| @goto error	188✔
94
95	@label done
96	return $(Expr(:tuple, value_names...)), pos, num_parsed	205✔
97
98	@label error
99	if raise	32✔
100	if directive_index > length(directives)	31✔
101	throw(ArgumentError("Found extra characters at the end of date time string"))	6✔
102	else
103	d = directives[directive_index]	25✔
104	throw(ArgumentError("Unable to parse date time. Expected directive $d at char $pos"))	25✔
105	end
106	end
107	return nothing	1✔
108	end
109	end
110
111	"""
112	tryparsenext_internal(::Type{<:TimeType}, str, pos, len, df::DateFormat, raise=false)
113
114	Parse the string according to the directives within the `DateFormat`. The specified `TimeType`
115	type determines the type of and order of tokens returned. If the given `DateFormat` or string
116	does not provide a required token a default value will be used. When the string cannot be
117	parsed the returned value will be `nothing` if `raise` is false otherwise an exception will
118	be thrown.
119
120	If successful, returns a 2-element tuple `(values, pos)`:
121	* `values::Tuple`: A tuple which contains a value
122	for each token as specified by the passed in type.
123	* `pos::Int`: The character index at which parsing stopped.
124	"""
125	@generated function tryparsenext_internal(::Type{T}, str::AbstractString, pos::Int, len::Int,	417✔
126	df::DateFormat, raise::Bool=false) where T<:TimeType
127	letters = character_codes(df)	322✔
128
129	tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]	161✔
130	value_names = Symbol[genvar(t) for t in tokens]	161✔
131
132	output_tokens = CONVERSION_TRANSLATIONS[T]	161✔
133	output_names = Symbol[genvar(t) for t in output_tokens]	1,214✔
134	output_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in output_tokens)	161✔
135
136	# Pre-assign output variables to defaults. Ensures that all output variables are
137	# assigned as the value tuple returned from `tryparsenext_core` may not include all
138	# of the required variables.
139	assign_defaults = Expr[	1,214✔
140	quote
141	$name = $default	193✔
142	end
143	for (name, default) in zip(output_names, output_defaults)
144	]
145
146	# Unpacks the value tuple returned by `tryparsenext_core` into separate variables.
147	value_tuple = Expr(:tuple, value_names...)	161✔
148
149	return quote	161✔
150	val = tryparsenext_core(str, pos, len, df, raise)	224✔
151	val === nothing && return nothing	194✔
152	values, pos, num_parsed = val	193✔
153	$(assign_defaults...)
154	$value_tuple = values	193✔
155	return $(Expr(:tuple, output_names...)), pos	193✔
156	end
157	end
158
159	@inline function tryparsenext_sign(str::AbstractString, i::Int, len::Int)
160	i > len && return nothing	198✔
161	c, ii = iterate(str, i)::Tuple{Char, Int}	396✔
162	if c == '+'	198✔
163	return 1, ii	4✔
164	elseif c == '-'	194✔
165	return -1, ii	6✔
166	else
167	return nothing	188✔
168	end
169	end
170
171	@inline function tryparsenext_base10(str::AbstractString, i::Int, len::Int, min_width::Int=1, max_width::Int=0)
172	i > len && return nothing	823✔
173	min_pos = min_width <= 0 ? i : i + min_width - 1	1,453✔
174	max_pos = max_width <= 0 ? len : min(i + max_width - 1, len)	845✔
175	d::Int64 = 0	775✔
176	@inbounds while i <= max_pos	775✔
177	c, ii = iterate(str, i)::Tuple{Char, Int}	4,635✔
178	if '0' <= c <= '9'	2,319✔
179	d = d * 10 + (c - '0')	1,854✔
180	else
181	break	465✔
182	end
183	i = ii	1,854✔
184	end	1,854✔
185	if i <= min_pos	775✔
186	return nothing	3✔
187	else
188	return d, i	772✔
189	end
190	end
191
192	@inline function tryparsenext_word(str::AbstractString, i, len, locale, maxchars=0)
193	word_start, word_end = i, 0	35✔
194	max_pos = maxchars <= 0 ? len : min(len, nextind(str, i, maxchars-1))	41✔
195	@inbounds while i <= max_pos	35✔
196	c, ii = iterate(str, i)::Tuple{Char, Int}	275✔
197	if isletter(c)	142✔
198	word_end = i	111✔
199	else
200	break	28✔
201	end
202	i = ii	111✔
203	end	111✔
204	if word_end == 0	35✔
205	return nothing	2✔
206	else
207	return SubString(str, word_start, word_end), i	33✔
208	end
209	end
210
211	function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeFormat))	28✔
212	i, end_pos = firstindex(s), lastindex(s)	52✔
213	i > end_pos && throw(ArgumentError("Cannot parse an empty string as a DateTime"))	28✔
214
215	coefficient = 1	24✔
216	local dy
217	dm = dd = Int64(1)	24✔
218	th = tm = ts = tms = Int64(0)	24✔
219
220	# Optional sign
221	let val = tryparsenext_sign(s, i, end_pos)	48✔
222	if val !== nothing	24✔
223	coefficient, i = val	4✔
224	end
225	end
226
227	let val = tryparsenext_base10(s, i, end_pos, 1)	46✔
228	val === nothing && @goto error	24✔
229	dy, i = val	22✔
230	i > end_pos && @goto done	22✔
231	end
232
233	c, i = iterate(s, i)::Tuple{Char, Int}	42✔
234	c != '-' && @goto error	21✔
235	i > end_pos && @goto done	21✔
236
237	let val = tryparsenext_base10(s, i, end_pos, 1, 2)	42✔
238	val === nothing && @goto error	21✔
239	dm, i = val	21✔
240	i > end_pos && @goto done	21✔
241	end
242
243	c, i = iterate(s, i)::Tuple{Char, Int}	42✔
244	c != '-' && @goto error	21✔
245	i > end_pos && @goto done	21✔
246
247	let val = tryparsenext_base10(s, i, end_pos, 1, 2)	42✔
248	val === nothing && @goto error	21✔
249	dd, i = val	21✔
250	i > end_pos && @goto done	21✔
251	end
252
253	c, i = iterate(s, i)::Tuple{Char, Int}	22✔
254	c != 'T' && @goto error	11✔
255	i > end_pos && @goto done	11✔
256
257	let val = tryparsenext_base10(s, i, end_pos, 1, 2)	22✔
258	val === nothing && @goto error	11✔
259	th, i = val	11✔
260	i > end_pos && @goto done	11✔
261	end
262
263	c, i = iterate(s, i)::Tuple{Char, Int}	22✔
264	c != ':' && @goto error	11✔
265	i > end_pos && @goto done	11✔
266
267	let val = tryparsenext_base10(s, i, end_pos, 1, 2)	22✔
268	val === nothing && @goto error	11✔
269	tm, i = val	11✔
270	i > end_pos && @goto done	11✔
271	end
272
273	c, i = iterate(s, i)::Tuple{Char, Int}	22✔
274	c != ':' && @goto error	11✔
275	i > end_pos && @goto done	11✔
276
277	let val = tryparsenext_base10(s, i, end_pos, 1, 2)	22✔
278	val === nothing && @goto error	11✔
279	ts, i = val	11✔
280	i > end_pos && @goto done	11✔
281	end
282
UNCOV 283	c, i = iterate(s, i)::Tuple{Char, Int}	×
UNCOV 284	c != '.' && @goto error	×
UNCOV 285	i > end_pos && @goto done	×
286
UNCOV 287	let val = tryparsenext_base10(s, i, end_pos, 1, 3)	×
UNCOV 288	val === nothing && @goto error	×
UNCOV 289	tms, j = val	×
UNCOV 290	tms *= 10 ^ (3 - (j - i))	×
UNCOV 291	j > end_pos \|\| @goto error	×
292	end
293
294	@label done
295	return DateTime(dy * coefficient, dm, dd, th, tm, ts, tms)	22✔
296
297	@label error
298	throw(ArgumentError("Invalid DateTime string"))	2✔
299	end
300
301	function Base.parse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType	244✔
302	pos, len = firstindex(str), lastindex(str)	465✔
303	pos > len && throw(ArgumentError("Cannot parse an empty string as a Date or Time"))	238✔
304	val = tryparsenext_internal(T, str, pos, len, df, true)	412✔
305	@assert val !== nothing	191✔
306	values, endpos = val	191✔
307	return T(values...)::T	191✔
308	end
309
310	function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType	13✔
311	pos, len = firstindex(str), lastindex(str)	16✔
312	pos > len && return nothing	9✔
313	res = tryparsenext_internal(T, str, pos, len, df, false)	5✔
314	res === nothing && return nothing	3✔
315	values, endpos = res	2✔
316	if validargs(T, values...) === nothing	2✔
317	# TODO: validargs gets called twice, since it's called again in the T constructor
318	return T(values...)::T	1✔
319	end
320	return nothing	1✔
321	end
322
323	"""
324	parse_components(str::AbstractString, df::DateFormat) -> Array{Any}
325
326	Parse the string into its components according to the directives in the `DateFormat`.
327	Each component will be a distinct type, typically a subtype of Period. The order of the
328	components will match the order of the `DatePart` directives within the `DateFormat`. The
329	number of components may be less than the total number of `DatePart`.
330	"""
331	@generated function parse_components(str::AbstractString, df::DateFormat)	13✔
332	letters = character_codes(df)	10✔
333	tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters]	5✔
334
335	return quote	5✔
336	pos, len = firstindex(str), lastindex(str)	26✔
337	val = tryparsenext_core(str, pos, len, df, #=raise=#true)	13✔
338	@assert val !== nothing	12✔
339	values, pos, num_parsed = val	12✔
340	types = $(Expr(:tuple, tokens...))	12✔
341	result = Vector{Any}(undef, num_parsed)	24✔
342	for (i, typ) in enumerate(types)	12✔
343	i > num_parsed && break	53✔
344	result[i] = typ(values[i]) # Constructing types takes most of the time	53✔
345	end	53✔
346	return result	12✔
347	end
348	end

JuliaLang / julia / #37859

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous