Deprecate rsearch and fix multiple things

Author: nalimilan

base/deprecated.jl

@@ -2120,21 +2120,42 @@ finalizer(f::Ptr{Void}, o::Function) = invoke(finalizer, Tuple{Ptr{Void}, Any},
 @deprecate search(str::Union{String,SubString}, re::Regex) findfirst(re, str)
 @deprecate search(s::AbstractString, r::Regex, idx::Integer) findnext(r, s, idx)
 @deprecate search(s::AbstractString, r::Regex) findfirst(r, s)
-@deprecate search(s::String, c::Char, i::Integer) findnext(equalto(c), s, i)
-@deprecate search(s::String, c::Char) findfirst(equalto(c), s)
+@deprecate search(s::AbstractString, c::Char, i::Integer) findnext(equalto(c), s, i)
+@deprecate search(s::AbstractString, c::Char) findfirst(equalto(c), s)
 # FIXME: no replacement to search for a multibyte char in a ByteArray
-@deprecate search(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = 1) findnext(equalto(b), a, i)
-@deprecate search(a::String, b::Union{Int8,UInt8}, i::Integer = 1) findnext(equalto(Char(b)), a, i)
-@deprecate search(a::ByteArray, b::Char, i::Integer = 1) findnext(equalto(Unt8(b)), a, i)
+@deprecate search(a::ByteArray, b::Union{Int8,UInt8}, i::Integer) findnext(equalto(b), a, i)
+@deprecate search(a::ByteArray, b::Union{Int8,UInt8}) findfirst(equalto(b), a)
+@deprecate search(a::String, b::Union{Int8,UInt8}, i::Integer) findnext(equalto(b), Vector{UInt8}(a), i)
+@deprecate search(a::String, b::Union{Int8,UInt8}) findfirst(equalto(b), Vector{UInt8}(a))
+@deprecate search(a::ByteArray, b::Char, i::Integer) findnext(equalto(UInt8(b)), a, i)
+@deprecate search(a::ByteArray, b::Char) findfirst(equalto(UInt8(b)), a)
 
 @deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}, i::Integer) findnext(x -> x in c, s, i)
-@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findfirst(x -> x in c, s, i)
+@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findfirst(x -> x in c, s)
 @deprecate search(s::AbstractString, t::AbstractString, i::Integer) findnext(t, s, i)
 @deprecate search(s::AbstractString, t::AbstractString) findfirst(t, s)
 
 @deprecate search(buf::IOBuffer, delim::UInt8) findfirst(equalto(delim), buf)
 @deprecate search(buf::Base.GenericIOBuffer, delim::UInt8) findfirst(equalto(delim), buf)
 
+@deprecate rsearch(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}, i::Integer) findprev(x -> x in c, s, i)
+@deprecate rsearch(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findlast(x -> x in c, s)
+@deprecate rsearch(s::AbstractString, t::AbstractString, i::Integer) findprev(t, s, i)
+@deprecate rsearch(s::AbstractString, t::AbstractString) findlast(t, s)
+@deprecate rsearch(s::ByteArray, t::ByteArray, i::Integer) findprev(t, s, i)
+@deprecate rsearch(s::ByteArray, t::ByteArray) findlast(t, s)
+
+@deprecate rsearch(str::Union{String,SubString}, re::Regex, idx::Integer) findprev(re, str, idx)
+@deprecate rsearch(str::Union{String,SubString}, re::Regex) findlast(re, str)
+@deprecate rsearch(s::AbstractString, r::Regex, idx::Integer) findprev(r, s, idx)
+@deprecate rsearch(s::AbstractString, r::Regex) findlast(r, s)
+@deprecate rsearch(s::AbstractString, c::Char, i::Integer) findprev(equalto(c), s, i)
+@deprecate rsearch(s::AbstractString, c::Char) findlast(equalto(c), s)
+# FIXME: no replacement to search for a multibyte char in a ByteArray
+@deprecate rsearch(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = endof(a)) findprev(equalto(b), a, i)
+@deprecate rsearch(a::String, b::Union{Int8,UInt8}, i::Integer = endof(a)) findprev(equalto(Char(b)), a, i)
+@deprecate rsearch(a::ByteArray, b::Char, i::Integer = endof(a)) findprev(equalto(UInt8(b)), a, i)
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/exports.jl

@@ -771,7 +771,6 @@ export
     repr,
     reverseind,
     rpad,
-    rsearch,
     rsearchindex,
     rsplit,
     rstrip,

base/libgit2/types.jl

@@ -894,7 +894,7 @@ function Base.split(ce::ConfigEntry)
 
     # Determine the positions of the delimiters
     subsection_delim = findfirst(equalto('.'), key)
-    name_delim = rsearch(key, '.')
+    name_delim = findlast(equalto('.'), key)
 
     section = SubString(key, 1, subsection_delim - 1)
     subsection = SubString(key, subsection_delim + 1, name_delim - 1)

base/precompile.jl

@@ -192,16 +192,16 @@ precompile(Tuple{typeof(Base.REPL.ip_matches_func), Ptr{Void}, Symbol})
 precompile(Tuple{typeof(Base.throw_boundserror), Array{Ptr{Void}, 1}, Tuple{Base.UnitRange{Int64}}})
 precompile(Tuple{typeof(Base.unsafe_copy!), Array{Ptr{Void}, 1}, Int64, Array{Ptr{Void}, 1}, Int64, Int64})
 precompile(Tuple{Type{Base.Channel{Any}}, Int64})
-precompile(Tuple{typeof(Base.rsearch), String, UInt8, Int64})
-precompile(Tuple{typeof(Base.rsearch), String, Char, Int64})
-precompile(Tuple{typeof(Base.rsearch), Array{UInt8, 1}, UInt8, Int64})
+precompile(Tuple{typeof(Base._rsearch), String, UInt8, Int64})
+precompile(Tuple{typeof(Base._rsearch), String, Char, Int64})
+precompile(Tuple{typeof(Base._rsearch), Array{UInt8, 1}, UInt8, Int64})
 precompile(Tuple{typeof(Base._rsearchindex), Array{UInt8, 1}, Array{UInt8, 1}, Int64})
 precompile(Tuple{typeof(Base._rsearch), Array{UInt8, 1}, Array{UInt8, 1}, Int64})
-precompile(Tuple{typeof(Base.rsearch), Array{Int8, 1}, UInt8, Int64})
+precompile(Tuple{typeof(Base._rsearch), Array{Int8, 1}, UInt8, Int64})
 precompile(Tuple{typeof(Base._rsearchindex), Array{Int8, 1}, Array{UInt8, 1}, Int64})
 precompile(Tuple{typeof(Base._rsearch), Array{Int8, 1}, Array{UInt8, 1}, Int64})
-precompile(Tuple{typeof(Base.rsearch), Array{UInt8, 1}, Char, Int64})
-precompile(Tuple{typeof(Base.rsearch), Array{Int8, 1}, Char, Int64})
+precompile(Tuple{typeof(Base._rsearch), Array{UInt8, 1}, Char, Int64})
+precompile(Tuple{typeof(Base._rsearch), Array{Int8, 1}, Char, Int64})
 precompile(Tuple{typeof(Base.splice!), Array{Base.Multimedia.Display, 1}, Int64, Array{Any, 1}})
 precompile(Tuple{typeof(Core.Inference.isbits), Base.LineEdit.EmptyCompletionProvider})
 precompile(Tuple{typeof(Core.Inference.isbits), Base.LineEdit.EmptyHistoryProvider})
@@ -583,7 +583,7 @@ precompile(Tuple{typeof(Base.LineEdit.complete_line), Base.REPL.REPLCompletionPr
 precompile(Tuple{getfield(Base, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.parse), String})
 precompile(Tuple{typeof(Base.isvalid), Base.RevString{String}, Int64})
 precompile(Tuple{typeof(Base.nextind), Base.RevString{String}, Int64})
-precompile(Tuple{typeof(Base.rsearch), String, Array{Char, 1}, Int64})
+precompile(Tuple{typeof(Base._rsearch), String, Array{Char, 1}, Int64})
 precompile(Tuple{getfield(Base.REPLCompletions, Symbol("#kw##find_start_brace")), Array{Any, 1}, typeof(Base.REPLCompletions.find_start_brace), String})
 precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Void, Void, Void}})
 precompile(Tuple{typeof(Base.isidentifier), Base.SubString{String}})
@@ -665,7 +665,7 @@ precompile(Tuple{typeof(Base.rsearchindex), String, String, Int64})
 precompile(Tuple{typeof(Base._rsearch), String, String, Int64})
 precompile(Tuple{typeof(Base.unshift!), Array{Base.SubString{String}, 1}, Base.SubString{String}})
 precompile(Tuple{typeof(Base.startswith), String, Base.SubString{String}})
-precompile(Tuple{typeof(Base.rsearch), String, Array{Char, 1}})
+precompile(Tuple{typeof(Base._rsearch), String, Array{Char, 1}})
 precompile(Tuple{getfield(Base, Symbol("#kw##rsplit")), Array{Any, 1}, typeof(Base.rsplit), String, String})
 precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Base.Sort.MergeSortAlg, Base.Order.ForwardOrdering})
 precompile(Tuple{typeof(Base.sort!), Array{String, 1}, Int64, Int64, Base.Sort.InsertionSortAlg, Base.Order.ForwardOrdering})

base/repl/LineEdit.jl

@@ -487,11 +487,11 @@ end
 # of the line.
 
 function edit_move_up(buf::IOBuffer)
-    npos = rsearch(buf.data, '\n', position(buf))
+    npos = findprev(equalto(UInt8('\n')), buf.data, position(buf))
     npos == 0 && return false # we're in the first line
     # We're interested in character count, not byte count
     offset = length(content(buf, npos => position(buf)))
-    npos2 = rsearch(buf.data, '\n', npos-1)
+    npos2 = findprev(equalto(UInt8('\n')), buf.data, npos-1)
     seek(buf, npos2)
     for _ = 1:offset
         pos = position(buf)
@@ -509,7 +509,7 @@ function edit_move_up(s)
 end
 
 function edit_move_down(buf::IOBuffer)
-    npos = rsearch(buf.data[1:buf.size], '\n', position(buf))
+    npos = findprev(equalto(UInt8('\n')), buf.data[1:buf.size], position(buf))
     # We're interested in character count, not byte count
     offset = length(String(buf.data[(npos+1):(position(buf))]))
     npos2 = findnext(equalto(UInt8('\n')), buf.data[1:buf.size], position(buf)+1)
@@ -1603,7 +1603,7 @@ function move_line_start(s::MIState)
     if s.key_repeats > 0
         move_input_start(s)
     else
-        seek(buf, rsearch(buf.data, '\n', curpos))
+        seek(buf, findprev(equalto(UInt8('\n')), buf.data, curpos))
     end
     :move_line_start
 end

base/repl/REPL.jl

@@ -583,14 +583,15 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
 
     !skip_current && searchdata == response_str[a:b] && return true
 
-    searchfunc, searchstart, skipfunc = backwards ? (rsearch, b, prevind) :
-                                                    (findfirst,  a, nextind)
+    searchfunc1, searchfunc2, searchstart, skipfunc = backwards ?
+                                                      (findlast, findprev, b, prevind) :
+                                                      (findfirst, findnext, a, nextind)
     skip_current && (searchstart = skipfunc(response_str, searchstart))
 
     # Start searching
     # First the current response buffer
     if 1 <= searchstart <= endof(response_str)
-        match = searchfunc(response_str, searchdata, searchstart)
+        match = searchfunc2(searchdata, response_str, searchstart)
         if match != 0:-1
             seek(response_buffer, first(match) - 1)
             return true
@@ -601,7 +602,7 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
     idxs = backwards ? ((hist.cur_idx-1):-1:1) : ((hist.cur_idx+1):length(hist.history))
     for idx in idxs
         h = hist.history[idx]
-        match = searchfunc === findfirst ? findfirst(searchdata, h) : rsearch(h, searchdata)
+        match = searchfunc1(searchdata, h)
         if match != 0:-1 && h != response_str && haskey(hist.mode_mapping, hist.modes[idx])
             truncate(response_buffer, 0)
             write(response_buffer, h)
@@ -1019,7 +1020,7 @@ input_color(r::StreamREPL) = r.input_color
 # heuristic function to decide if the presence of a semicolon
 # at the end of the expression was intended for suppressing output
 function ends_with_semicolon(line::AbstractString)
-    match = rsearch(line, ';')
+    match = findlast(equalto(';'), line)
     if match != 0
         # state for comment parser, assuming that the `;` isn't in a string or comment
         # so input like ";#" will still thwart this to give the wrong (anti-conservative) answer

base/repl/REPLCompletions.jl

@@ -40,7 +40,7 @@ function complete_symbol(sym, ffunc)
 
     lookup_module = true
     t = Union{}
-    if rsearch(sym, non_identifier_chars) < rsearch(sym, '.')
+    if findlast(x -> x in non_identifier_chars, sym) < findlast(equalto('.'), sym)
         # Find module
         lookup_name, name = rsplit(sym, ".", limit=2)
 
@@ -257,7 +257,7 @@ function find_start_brace(s::AbstractString; c_start='(', c_end=')')
     end
     braces != 1 && return 0:-1, -1
     method_name_end = reverseind(r, i)
-    startind = nextind(s, rsearch(s, non_identifier_chars, method_name_end))
+    startind = nextind(s, findprev(x -> x in non_identifier_chars, s, method_name_end))
     return (startind:endof(s), method_name_end)
 end
 
@@ -412,8 +412,8 @@ function afterusing(string::String, startpos::Int)
 end
 
 function bslash_completions(string, pos)
-    slashpos = rsearch(string, '\\', pos)
-    if (rsearch(string, bslash_separators, pos) < slashpos &&
+    slashpos = findprev(equalto('\\'), string, pos)
+    if (findprev(x -> x in bslash_separators, string, pos) < slashpos &&
         !(1 < slashpos && (string[prevind(string, slashpos)]=='\\')))
         # latex / emoji symbol substitution
         s = string[slashpos:pos]
@@ -536,8 +536,8 @@ function completions(string, pos)
         return String[], 0:-1, false
     end
 
-    dotpos = rsearch(string, '.', pos)
-    startpos = nextind(string, rsearch(string, non_identifier_chars, pos))
+    dotpos = findprev(equalto('.'), string, pos)
+    startpos = nextind(string, findprev(x -> x in non_identifier_chars, string, pos))
 
     ffunc = (mod,x)->true
     suggestions = String[]

base/stream.jl

@@ -1185,7 +1185,7 @@ end
 show(io::IO, s::BufferStream) = print(io,"BufferStream() bytes waiting:",nb_available(s.buffer),", isopen:", s.is_open)
 
 function wait_readbyte(s::BufferStream, c::UInt8)
-    while isopen(s) && findfirst(equalto(c), x.buffer) <= 0
+    while isopen(s) && findfirst(equalto(c), s.buffer) <= 0
         wait(s.r_c)
     end
 end

base/strings/search.jl

@@ -22,7 +22,7 @@ findfirst(pattern::AbstractString, string::AbstractString) =
     findnext(pattern, string, start(string))
 
 # AbstractString implementation of the generic findnext interface
-function findnext(testf::Function, s::AbstractString, i::Integer=start(s))
+function findnext(testf::Function, s::AbstractString, i::Integer)
     @boundscheck (i < 1 || i > nextind(s,endof(s))) && throw(BoundsError(s, i))
     @inbounds while !done(s,i)
         d, j = next(s,i)
@@ -45,7 +45,7 @@ function _searchindex(s::Union{AbstractString,ByteArray},
     end
     t1, j2 = next(t,start(t))
     while true
-        i = _searchindex(s,t1,i)
+        i = findnext(equalto(t1),s,i)
         if i == 0 return 0 end
         c, ii = next(s,i)
         j = j2; k = ii
@@ -187,12 +187,12 @@ function _search(s, t, i::Integer)
 end
 
 """
-    findnext(pattern::AbstractString, string::AbstractString, [start::Integer])
-    findnext(pattern::Regex, string::String, [start::Integer])
+    findnext(pattern::AbstractString, string::AbstractString, start::Integer)
+    findnext(pattern::Regex, string::String, start::Integer)
 
-Find the first occurrence of `pattern` in `string`. `pattern` can be either a
-string, or a regular expression, in which case `string` must be of type `String`.
-`start` optionally specifies a starting index.
+Find the next occurrence of `pattern` in `string` starting at position `start`.
+`pattern` can be either a string, or a regular expression, in which case `string`
+must be of type `String`.
 
 The return value is a range of indexes where the matching sequence is found, such that
 `s[findnext(x, s, i)] == x`:
@@ -212,47 +212,50 @@ julia> findnext("Julia", "JuliaLang", 2)
 1:5
 ```
 """
-findnext(t::AbstractString, s::AbstractString, i::Integer=start(s)) = _search(s, t, i)
-findnext(t::ByteArray, s::ByteArray, i::Integer=start(s)) = _search(s, t, i)
-
-function rsearch(s::AbstractString, c::Chars)
-    f = c isa Char ? f = equalto(c) : x -> x in c
-    j = findfirst(f, RevString(s))
-    j == 0 && return 0
-    endof(s)-j+1
-end
+findnext(t::AbstractString, s::AbstractString, i::Integer) = _search(s, t, i)
+# TODO: remove?
+findnext(t::ByteArray, s::ByteArray, i::Integer) = _search(s, t, i)
 
 """
-    rsearch(s::AbstractString, chars::Chars, [start::Integer])
+    findlast(pattern::AbstractString, string::AbstractString)
+    findlast(pattern::Regex, string::String)
 
-Similar to `search` but returning the last occurrence of the given characters within the
-given string, searching in reverse from `start`.
+Find the last occurrence of `pattern` in `string`. Equivalent to
+[`findlast(pattern, string, endof(s))`](@ref).
 
 # Examples
 ```jldoctest
-julia> rsearch("aaabbb","b")
-6:6
+julia> findlast("o", "Hello to the world")
+15:15
+
+julia> findfirst("Julia", "JuliaLang")
+1:5
 ```
 """
-function rsearch(s::AbstractString, c::Chars, i::Integer)
-    f = c isa Char ? f = equalto(c) : x -> x in c
+findlast(pattern::AbstractString, string::AbstractString) =
+    findprev(pattern, string, endof(string))
+
+# AbstractString implementation of the generic findprev interface
+function findprev(testf::Function, s::AbstractString, i::Integer)
     e = endof(s)
-    j = findnext(f, RevString(s), e-i+1)
+    j = findnext(testf, RevString(s), e-i+1)
     j == 0 && return 0
     e-j+1
 end
 
-function _rsearchindex(s, t, i)
+function _rsearchindex(s::AbstractString,
+                       t::Union{AbstractString,Char,Int8,UInt8},
+                       i::Integer)
     if isempty(t)
         return 1 <= i <= nextind(s,endof(s)) ? i :
                throw(BoundsError(s, i))
     end
-    t = RevString(t)
+    t = t isa AbstractString ? RevString(t) : t
     rs = RevString(s)
     l = endof(s)
     t1, j2 = next(t,start(t))
     while true
-        i = rsearch(s,t1,i)
+        i = findprev(equalto(t1),s,i)
         if i == 0 return 0 end
         c, ii = next(rs,l-i+1)
         j = j2; k = ii
@@ -276,7 +279,10 @@ function _rsearchindex(s, t, i)
     end
 end
 
-function _rsearchindex(s::Union{String,ByteArray}, t::Union{String,ByteArray}, k)
+_rsearchindex(s::String, t::String, i::Integer) =
+    _rsearchindex(Vector{UInt8}(s), Vector{UInt8}(t), i)
+
+function _rsearchindex(s::ByteArray, t::ByteArray, k::Integer)
     n = sizeof(t)
     m = sizeof(s)
 
@@ -285,7 +291,7 @@ function _rsearchindex(s::Union{String,ByteArray}, t::Union{String,ByteArray}, k
     elseif m == 0
         return 0
     elseif n == 1
-        return rsearch(s, _nthbyte(t,1), k)
+        return findprev(equalto(_nthbyte(t,1)), s, k)
     end
 
     w = m - n
@@ -342,7 +348,7 @@ rsearchindex(s::ByteArray, t::ByteArray, i::Integer) = _rsearchindex(s,t,i)
 """
     rsearchindex(s::AbstractString, substring, [start::Integer])
 
-Similar to [`rsearch`](@ref), but return only the start index at which the substring is found, or `0` if it is not.
+Similar to `rsearch`, but return only the start index at which the substring is found, or `0` if it is not.
 
 # Examples
 ```jldoctest
@@ -360,7 +366,7 @@ function rsearchindex(s::String, t::String)
     # Check for fast case of a single byte
     # (for multi-byte UTF-8 sequences, use rsearchindex instead)
     if endof(t) == 1
-        rsearch(s, t[1])
+        findprev(equalto(t[1]), s)
     else
         _rsearchindex(s, t, sizeof(s))
     end
@@ -370,7 +376,7 @@ function rsearchindex(s::String, t::String, i::Integer)
     # Check for fast case of a single byte
     # (for multi-byte UTF-8 sequences, use rsearchindex instead)
     if endof(t) == 1
-        rsearch(s, t[1], i)
+        findprev(equalto(t[1]), s, i)
     elseif endof(t) != 0
         _rsearchindex(s, t, nextind(s, i)-1)
     elseif i > sizeof(s)
@@ -391,8 +397,9 @@ function _rsearch(s, t, i::Integer)
     end
 end
 
-rsearch(s::AbstractString, t::AbstractString, i::Integer=endof(s)) = _rsearch(s, t, i)
-rsearch(s::ByteArray, t::ByteArray, i::Integer=endof(s)) = _rsearch(s, t, i)
+findprev(t::AbstractString, s::AbstractString, i::Integer) = _rsearch(s, t, i)
+# TODO: remove?
+findprev(t::ByteArray, s::ByteArray, i::Integer) = _rsearch(s, t, i)
 
 """
     contains(haystack::AbstractString, needle::Union{AbstractString,Char})